Datasets:

Minata
/

src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 323k rows

src_fm_fc_ms_ff stringlengths 43 86.8k	target stringlengths 20 276k
FSUtils { public static boolean renameAndSetModifyTime(final FileSystem fs, final Path src, final Path dest) throws IOException { fs.setTimes(src, EnvironmentEdgeManager.currentTimeMillis(), -1); return fs.rename(src, dest); } protected FSUtils(); 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 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(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 boolean isPre020FileLayout(final FileSystem fs, final Path hbaseRootDir); static boolean isMajorCompactedPre020(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 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( final FileSystem fs, final Path hbaseRootDir); 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); 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(); }
SlabCache implements SlabItemActionWatcher, BlockCache, HeapSize { Entry<Integer, SingleSizeCache> getHigherBlock(int size) { return slabs.higherEntry(size - 1); } SlabCache(long size, long avgBlockSize); Map<Integer, SingleSizeCache> getSizer(); void addSlabByConf(Configuration conf); void cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem); void cacheBlock(BlockCacheKey cacheKey, Cacheable buf, boolean inMemory); CacheStats getStats(); Cacheable getBlock(BlockCacheKey key, boolean caching, boolean repeat, boolean updateCacheMetrics); boolean evictBlock(BlockCacheKey cacheKey); @Override void onEviction(BlockCacheKey key, SingleSizeCache notifier); @Override void onInsertion(BlockCacheKey key, SingleSizeCache notifier); void shutdown(); long heapSize(); long size(); long getFreeSize(); @Override long getBlockCount(); long getCurrentSize(); long getEvictedCount(); int evictBlocksByHfileName(String hfileName); @Override Iterator<CachedBlock> iterator(); @Override BlockCache[] getBlockCaches(); }	@Test public void testElementPlacement() { assertEquals(cache.getHigherBlock(BLOCK_SIZE).getKey().intValue(), (BLOCK_SIZE * 11 / 10)); assertEquals(cache.getHigherBlock((BLOCK_SIZE * 2)).getKey() .intValue(), (BLOCK_SIZE * 21 / 10)); }
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); String getIoEngine(); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable buf); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory); 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 getFailedBlockAdditions(); 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); for (int i = 0; !full; i++) { 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); String getIoEngine(); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable buf); @Override void cacheBlock(BlockCacheKey cacheKey, Cacheable cachedItem, boolean inMemory); 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 getFailedBlockAdditions(); 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); }
ByteBufferIOEngine implements IOEngine { public ByteBufferIOEngine(long capacity, boolean direct) throws IOException { this.capacity = capacity; this.direct = direct; bufferArray = new ByteBufferArray(capacity, direct); } ByteBufferIOEngine(long capacity, boolean direct); @Override String toString(); @Override boolean isPersistent(); @Override int read(ByteBuffer dstBuffer, long offset); @Override void write(ByteBuffer srcBuffer, long offset); @Override void sync(); @Override void shutdown(); }	@Test public void testByteBufferIOEngine() throws Exception { int capacity = 32 * 1024 * 1024; int testNum = 100; int maxBlockSize = 64 * 1024; ByteBufferIOEngine ioEngine = new ByteBufferIOEngine(capacity, false); int testOffsetAtStartNum = testNum / 10; int testOffsetAtEndNum = testNum / 10; for (int i = 0; i < testNum; i++) { byte val = (byte) (Math.random() * 255); int blockSize = (int) (Math.random() * maxBlockSize); if (blockSize == 0) { blockSize = 1; } byte[] byteArray = new byte[blockSize]; for (int j = 0; j < byteArray.length; ++j) { byteArray[j] = val; } ByteBuffer srcBuffer = ByteBuffer.wrap(byteArray); int offset = 0; if (testOffsetAtStartNum > 0) { testOffsetAtStartNum--; offset = 0; } else if (testOffsetAtEndNum > 0) { testOffsetAtEndNum--; offset = capacity - blockSize; } else { offset = (int) (Math.random() * (capacity - maxBlockSize)); } ioEngine.write(srcBuffer, offset); ByteBuffer dstBuffer = ByteBuffer.allocate(blockSize); ioEngine.read(dstBuffer, offset); byte[] byteArray2 = dstBuffer.array(); for (int j = 0; j < byteArray.length; ++j) { assertTrue(byteArray[j] == byteArray2[j]); } } assert testOffsetAtStartNum == 0; assert testOffsetAtEndNum == 0; }
FileIOEngine implements IOEngine { public FileIOEngine(String filePath, long fileSize) throws IOException { this.path = filePath; this.size = fileSize; try { raf = new RandomAccessFile(filePath, "rw"); } catch (java.io.FileNotFoundException fex) { LOG.error("Can't create bucket cache file " + filePath, fex); throw fex; } try { raf.setLength(fileSize); } catch (IOException ioex) { LOG.error("Can't extend bucket cache file; insufficient space for " + StringUtils.byteDesc(fileSize), ioex); raf.close(); throw ioex; } fileChannel = raf.getChannel(); LOG.info("Allocating " + StringUtils.byteDesc(fileSize) + ", on the path:" + filePath); } FileIOEngine(String filePath, long fileSize); @Override String toString(); @Override boolean isPersistent(); @Override int read(ByteBuffer dstBuffer, long offset); @Override void write(ByteBuffer srcBuffer, long offset); @Override void sync(); @Override void shutdown(); }	@Test public void testFileIOEngine() throws IOException { int size = 2 * 1024 * 1024; String filePath = "testFileIOEngine"; try { FileIOEngine fileIOEngine = new FileIOEngine(filePath, size); for (int i = 0; i < 50; i++) { int len = (int) Math.floor(Math.random() * 100); long offset = (long) Math.floor(Math.random() * size % (size - len)); byte[] data1 = new byte[len]; for (int j = 0; j < data1.length; ++j) { data1[j] = (byte) (Math.random() * 255); } byte[] data2 = new byte[len]; fileIOEngine.write(ByteBuffer.wrap(data1), offset); fileIOEngine.read(ByteBuffer.wrap(data2), offset); for (int j = 0; j < data1.length; ++j) { assertTrue(data1[j] == data2[j]); } } } finally { File file = new File(filePath); if (file.exists()) { file.delete(); } } }
HFileBlock implements Cacheable { public int getUncompressedSizeWithoutHeader() { return uncompressedSizeWithoutHeader; } HFileBlock(BlockType blockType, int onDiskSizeWithoutHeader, int uncompressedSizeWithoutHeader, long prevBlockOffset, ByteBuffer buf, boolean fillHeader, long offset, int onDiskDataSizeWithHeader, HFileContext fileContext); HFileBlock(ByteBuffer b, boolean usesHBaseChecksum); BlockType getBlockType(); short getDataBlockEncodingId(); int getOnDiskSizeWithHeader(); int getOnDiskSizeWithoutHeader(); int getUncompressedSizeWithoutHeader(); long getPrevBlockOffset(); ByteBuffer getBufferWithoutHeader(); ByteBuffer getBufferReadOnly(); ByteBuffer getBufferReadOnlyWithHeader(); @Override String toString(); void assumeUncompressed(); void expectType(BlockType expectedType); long getOffset(); DataInputStream getByteStream(); @Override long heapSize(); static boolean readWithExtra(InputStream in, byte buf[], int bufOffset, int necessaryLen, int extraLen); int getNextBlockOnDiskSizeWithHeader(); @Override int getSerializedLength(); @Override void serialize(ByteBuffer destination); void serializeExtraInfo(ByteBuffer destination); @Override CacheableDeserializer<Cacheable> getDeserializer(); @Override boolean equals(Object comparison); DataBlockEncoding getDataBlockEncoding(); int headerSize(); static int headerSize(boolean usesHBaseChecksum); byte[] getDummyHeaderForVersion(); HFileContext getHFileContext(); static final boolean FILL_HEADER; static final boolean DONT_FILL_HEADER; static final int ENCODED_HEADER_SIZE; static final int BYTE_BUFFER_HEAP_SIZE; static final int EXTRA_SERIALIZATION_SPACE; }	@Test public void testNoCompression() throws IOException { assertEquals(4000, createTestV2Block(NONE, includesMemstoreTS, false). getBlockForCaching().getUncompressedSizeWithoutHeader()); }
CacheConfig { public BlockCache getBlockCache() { return this.blockCache; } CacheConfig(Configuration conf, HColumnDescriptor family); CacheConfig(Configuration conf); CacheConfig(final BlockCache blockCache, final boolean cacheDataOnRead, final boolean inMemory, final boolean cacheDataOnWrite, final boolean cacheIndexesOnWrite, final boolean cacheBloomsOnWrite, final boolean evictOnClose, final boolean cacheCompressed, final boolean prefetchOnOpen); CacheConfig(CacheConfig cacheConf); boolean isBlockCacheEnabled(); BlockCache getBlockCache(); boolean shouldCacheDataOnRead(); boolean shouldCacheBlockOnRead(BlockCategory category); boolean isInMemory(); boolean shouldCacheDataOnWrite(); void setCacheDataOnWrite(boolean cacheDataOnWrite); boolean shouldCacheIndexesOnWrite(); boolean shouldCacheBloomsOnWrite(); boolean shouldEvictOnClose(); void setEvictOnClose(boolean evictOnClose); boolean shouldCacheCompressed(); boolean shouldPrefetchOnOpen(); @Override String toString(); static synchronized BlockCache instantiateBlockCache(Configuration conf); static final String CACHE_BLOCKS_ON_WRITE_KEY; static final String CACHE_INDEX_BLOCKS_ON_WRITE_KEY; static final String CACHE_BLOOM_BLOCKS_ON_WRITE_KEY; static final String CACHE_DATA_BLOCKS_COMPRESSED_KEY; static final String EVICT_BLOCKS_ON_CLOSE_KEY; static final String BUCKET_CACHE_IOENGINE_KEY; static final String BUCKET_CACHE_SIZE_KEY; static final String BUCKET_CACHE_PERSISTENT_PATH_KEY; static final String BUCKET_CACHE_COMBINED_KEY; static final String BUCKET_CACHE_COMBINED_PERCENTAGE_KEY; static final String BUCKET_CACHE_WRITER_THREADS_KEY; static final String BUCKET_CACHE_WRITER_QUEUE_KEY; static final String BUCKET_CACHE_BUCKETS_KEY; static final boolean DEFAULT_BUCKET_CACHE_COMBINED; static final int DEFAULT_BUCKET_CACHE_WRITER_THREADS; static final int DEFAULT_BUCKET_CACHE_WRITER_QUEUE; static final float DEFAULT_BUCKET_CACHE_COMBINED_PERCENTAGE; static final String SLAB_CACHE_OFFHEAP_PERCENTAGE_KEY; static final String PREFETCH_BLOCKS_ON_OPEN_KEY; static final boolean DEFAULT_CACHE_DATA_ON_READ; static final boolean DEFAULT_CACHE_DATA_ON_WRITE; static final boolean DEFAULT_IN_MEMORY; static final boolean DEFAULT_CACHE_INDEXES_ON_WRITE; static final boolean DEFAULT_CACHE_BLOOMS_ON_WRITE; static final boolean DEFAULT_EVICT_ON_CLOSE; static final boolean DEFAULT_COMPRESSED_CACHE; static final boolean DEFAULT_PREFETCH_ON_OPEN; }	@Test public void testSlabCacheConfig() { this.conf.setFloat(CacheConfig.SLAB_CACHE_OFFHEAP_PERCENTAGE_KEY, 0.1f); CacheConfig cc = new CacheConfig(this.conf); basicBlockCacheOps(cc, true, true); assertTrue(cc.getBlockCache() instanceof DoubleBlockCache); } @Test public void testBucketCacheConfig() { this.conf.set(CacheConfig.BUCKET_CACHE_IOENGINE_KEY, "offheap"); this.conf.setInt(CacheConfig.BUCKET_CACHE_SIZE_KEY, 100); this.conf.setFloat(CacheConfig.BUCKET_CACHE_COMBINED_PERCENTAGE_KEY, 0.8f); CacheConfig cc = new CacheConfig(this.conf); basicBlockCacheOps(cc, false, false); assertTrue(cc.getBlockCache() instanceof CombinedBlockCache); }
HalfStoreFileReader extends StoreFile.Reader { @Override public byte[] midkey() throws IOException { return null; } HalfStoreFileReader(final FileSystem fs, final Path p, final CacheConfig cacheConf, final Reference r, final Configuration conf); HalfStoreFileReader(final FileSystem fs, final Path p, final FSDataInputStreamWrapper in, long size, final CacheConfig cacheConf, final Reference r, final Configuration conf); @Override HFileScanner getScanner(final boolean cacheBlocks, final boolean pread, final boolean isCompaction); @Override boolean passesKeyRangeFilter(Scan scan); @Override byte[] getLastKey(); @Override byte[] midkey(); @Override byte[] getFirstKey(); @Override long getEntries(); @Override long getFilterEntries(); }	@Test public void testHalfScanAndReseek() throws IOException { String root_dir = TEST_UTIL.getDataTestDir().toString(); Path p = new Path(root_dir, "test"); Configuration conf = TEST_UTIL.getConfiguration(); FileSystem fs = FileSystem.get(conf); CacheConfig cacheConf = new CacheConfig(conf); HFileContext meta = new HFileContextBuilder().withBlockSize(1024).build(); HFile.Writer w = HFile.getWriterFactory(conf, cacheConf) .withPath(fs, p) .withFileContext(meta) .create(); List<KeyValue> items = genSomeKeys(); for (KeyValue kv : items) { w.append(kv); } w.close(); HFile.Reader r = HFile.createReader(fs, p, cacheConf, conf); r.loadFileInfo(); byte [] midkey = r.midkey(); KeyValue midKV = KeyValue.createKeyValueFromKey(midkey); midkey = midKV.getRow(); Reference bottom = new Reference(midkey, Reference.Range.bottom); doTestOfScanAndReseek(p, fs, bottom, cacheConf); Reference top = new Reference(midkey, Reference.Range.top); doTestOfScanAndReseek(p, fs, top, cacheConf); r.close(); } @Test public void testHalfScanner() throws IOException { String root_dir = TEST_UTIL.getDataTestDir().toString(); Path p = new Path(root_dir, "test"); Configuration conf = TEST_UTIL.getConfiguration(); FileSystem fs = FileSystem.get(conf); CacheConfig cacheConf = new CacheConfig(conf); HFileContext meta = new HFileContextBuilder().withBlockSize(1024).build(); HFile.Writer w = HFile.getWriterFactory(conf, cacheConf) .withPath(fs, p) .withFileContext(meta) .create(); List<KeyValue> items = genSomeKeys(); for (KeyValue kv : items) { w.append(kv); } w.close(); HFile.Reader r = HFile.createReader(fs, p, cacheConf, conf); r.loadFileInfo(); byte[] midkey = r.midkey(); KeyValue midKV = KeyValue.createKeyValueFromKey(midkey); midkey = midKV.getRow(); Reference bottom = new Reference(midkey, Reference.Range.bottom); Reference top = new Reference(midkey, Reference.Range.top); KeyValue beforeMidKey = null; for (KeyValue item : items) { if (KeyValue.COMPARATOR.compare(item, midKV) >= 0) { break; } beforeMidKey = item; } System.out.println("midkey: " + midKV + " or: " + Bytes.toStringBinary(midkey)); System.out.println("beforeMidKey: " + beforeMidKey); Cell foundKeyValue = doTestOfSeekBefore(p, fs, bottom, midKV, cacheConf); assertEquals(beforeMidKey, foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, top, items.get(items.size() - 1), cacheConf); assertEquals(items.get(items.size() - 2), foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, bottom, items.get(items.size() - 1), cacheConf); assertEquals(beforeMidKey, foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, top, items.get(0), cacheConf); assertNull(foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, bottom, items.get(0), cacheConf); assertNull(foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, top, items.get(1), cacheConf); assertNull(foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, bottom, items.get(1), cacheConf); assertEquals(items.get(0), foundKeyValue); foundKeyValue = doTestOfSeekBefore(p, fs, top, midKV, cacheConf); assertNull(foundKeyValue); }
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); }	@Test public void testParsingWritableReference() throws IOException { final String datafile = System.getProperty("project.build.testSourceDirectory", "src/test") + File.separator + "data" + File.separator + "a6a6562b777440fd9c34885428f5cb61.21e75333ada3d5bafb34bb918f29576c"; FileSystem fs = FileSystem.get(HTU.getConfiguration()); Reference.read(fs, new Path(datafile)); }
HDFSBlocksDistribution { public void addHostsAndBlockWeight(String[] hosts, long weight) { if (hosts == null \|\| hosts.length == 0) { return; } addUniqueWeight(weight); for (String hostname : hosts) { addHostAndBlockWeight(hostname, weight); } } HDFSBlocksDistribution(); @Override synchronized String toString(); void addHostsAndBlockWeight(String[] hosts, long weight); Map<String,HostAndWeight> getHostAndWeights(); long getWeight(String host); long getUniqueBlocksTotalWeight(); float getBlockLocalityIndex(String host); void add(HDFSBlocksDistribution otherBlocksDistribution); List<String> getTopHosts(); HostAndWeight[] getTopHostsWithWeights(); }	@Test public void testAddHostsAndBlockWeight() throws Exception { HDFSBlocksDistribution distribution = new HDFSBlocksDistribution(); distribution.addHostsAndBlockWeight(null, 100); assertEquals("Expecting no hosts weights", 0, distribution.getHostAndWeights().size()); distribution.addHostsAndBlockWeight(new String[0], 100); assertEquals("Expecting no hosts weights", 0, distribution.getHostAndWeights().size()); distribution.addHostsAndBlockWeight(new String[] {"test"}, 101); assertEquals("Should be one host", 1, distribution.getHostAndWeights().size()); distribution.addHostsAndBlockWeight(new String[] {"test"}, 202); assertEquals("Should be one host", 1, distribution.getHostAndWeights().size()); assertEquals("test host should have weight 303", 303, distribution.getHostAndWeights().get("test").getWeight()); distribution.addHostsAndBlockWeight(new String[] {"testTwo"}, 222); assertEquals("Should be two hosts", 2, distribution.getHostAndWeights().size()); assertEquals("Total weight should be 525", 525, distribution.getUniqueBlocksTotalWeight()); }
HDFSBlocksDistribution { public void add(HDFSBlocksDistribution otherBlocksDistribution) { Map<String,HostAndWeight> otherHostAndWeights = otherBlocksDistribution.getHostAndWeights(); for (Map.Entry<String, HostAndWeight> otherHostAndWeight: otherHostAndWeights.entrySet()) { addHostAndBlockWeight(otherHostAndWeight.getValue().host, otherHostAndWeight.getValue().weight); } addUniqueWeight(otherBlocksDistribution.getUniqueBlocksTotalWeight()); } HDFSBlocksDistribution(); @Override synchronized String toString(); void addHostsAndBlockWeight(String[] hosts, long weight); Map<String,HostAndWeight> getHostAndWeights(); long getWeight(String host); long getUniqueBlocksTotalWeight(); float getBlockLocalityIndex(String host); void add(HDFSBlocksDistribution otherBlocksDistribution); List<String> getTopHosts(); HostAndWeight[] getTopHostsWithWeights(); }	@Test public void testAdd() throws Exception { HDFSBlocksDistribution distribution = new HDFSBlocksDistribution(); distribution.add(new MockHDFSBlocksDistribution()); assertEquals("Expecting no hosts weights", 0, distribution.getHostAndWeights().size()); distribution.addHostsAndBlockWeight(new String[]{"test"}, 10); assertEquals("Should be one host", 1, distribution.getHostAndWeights().size()); distribution.add(new MockHDFSBlocksDistribution()); assertEquals("Should be one host", 1, distribution.getHostAndWeights().size()); assertEquals("Total weight should be 10", 10, distribution.getUniqueBlocksTotalWeight()); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @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); } requireGlobalPermission("createTable", Action.CREATE, desc.getTableName(), familyMap); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test 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); verifyDenied(createTable, USER_CREATE, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preBalance(ObserverContext<MasterCoprocessorEnvironment> c) throws IOException { requirePermission("balance", Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test 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); verifyDenied(action, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue) throws IOException { requirePermission("balanceSwitch", Action.ADMIN); return newValue; } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testBalanceSwitch() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preBalanceSwitch(ObserverContext.createAndPrepare(CP_ENV, null), true); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN); verifyDenied(action, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c) throws IOException { requirePermission("shutdown", Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testShutdown() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preShutdown(ObserverContext.createAndPrepare(CP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN); verifyDenied(action, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c) throws IOException { requirePermission("stopMaster", Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testStopMaster() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preStopMaster(ObserverContext.createAndPrepare(CP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN); verifyDenied(action, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preSplit(ObserverContext<RegionCoprocessorEnvironment> e) throws IOException { requirePermission("split", getTableName(e.getEnvironment()), null, null, Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testSplit() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preSplit(ObserverContext.createAndPrepare(RCP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE); } @Test public void testSplitWithSplitRow() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preSplit( ObserverContext.createAndPrepare(RCP_ENV, null), TEST_ROW); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preFlush(ObserverContext<RegionCoprocessorEnvironment> e) throws IOException { requirePermission("flush", getTableName(e.getEnvironment()), null, null, Action.ADMIN, Action.CREATE); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testFlush() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preFlush(ObserverContext.createAndPrepare(RCP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER, USER_CREATE); verifyDenied(action, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final InternalScanner scanner, final ScanType scanType) throws IOException { requirePermission("compact", getTableName(e.getEnvironment()), null, null, Action.ADMIN, Action.CREATE); return scanner; } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testCompact() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preCompact(ObserverContext.createAndPrepare(RCP_ENV, null), null, null, ScanType.COMPACT_RETAIN_DELETES); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER, USER_CREATE); verifyDenied(action, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates) throws IOException { requirePermission("compact", getTableName(e.getEnvironment()), null, null, Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testPreCompactSelection() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preCompactSelection(ObserverContext.createAndPrepare(RCP_ENV, null), null, null); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN, USER_OWNER); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void getUserPermissions(RpcController controller, AccessControlProtos.GetUserPermissionsRequest request, RpcCallback<AccessControlProtos.GetUserPermissionsResponse> done) { AccessControlProtos.GetUserPermissionsResponse response = null; try { if (aclRegion) { if (!initialized) { throw new CoprocessorException("AccessController not yet initialized"); } List<UserPermission> perms = null; if(request.getType() == AccessControlProtos.Permission.Type.Table) { TableName table = null; if (request.hasTableName()) { table = ProtobufUtil.toTableName(request.getTableName()); } requirePermission("userPermissions", table, null, null, Action.ADMIN); perms = AccessControlLists.getUserTablePermissions( regionEnv.getConfiguration(), table); } else if (request.getType() == AccessControlProtos.Permission.Type.Namespace) { perms = AccessControlLists.getUserNamespacePermissions( regionEnv.getConfiguration(), request.getNamespaceName().toStringUtf8()); } else { perms = AccessControlLists.getUserPermissions( regionEnv.getConfiguration(), null); } response = ResponseConverter.buildGetUserPermissionsResponse(perms); } else { throw new CoprocessorException(AccessController.class, "This method " + "can only execute at " + AccessControlLists.ACL_TABLE_NAME + " table."); } } catch (IOException ioe) { ResponseConverter.setControllerException(controller, ioe); } done.run(response); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testPermissionList() throws Exception { final TableName tableName = TableName.valueOf("testPermissionList"); final byte[] family1 = Bytes.toBytes("f1"); final byte[] family2 = Bytes.toBytes("f2"); final byte[] qualifier = Bytes.toBytes("q"); HBaseAdmin admin = TEST_UTIL.getHBaseAdmin(); if (admin.tableExists(tableName)) { admin.disableTable(tableName); admin.deleteTable(tableName); } HTableDescriptor htd = new HTableDescriptor(tableName); htd.addFamily(new HColumnDescriptor(family1)); htd.addFamily(new HColumnDescriptor(family2)); htd.setOwner(USER_OWNER); admin.createTable(htd); List<UserPermission> perms; HTable acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel service = acl.coprocessorService(tableName.getName()); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(service); perms = ProtobufUtil.getUserPermissions(protocol, tableName); } finally { acl.close(); } UserPermission ownerperm = new UserPermission( Bytes.toBytes(USER_OWNER.getName()), tableName, null, Action.values()); assertTrue("Owner should have all permissions on table", hasFoundUserPermission(ownerperm, perms)); User user = User.createUserForTesting(TEST_UTIL.getConfiguration(), "user", new String[0]); byte[] userName = Bytes.toBytes(user.getShortName()); UserPermission up = new UserPermission(userName, tableName, family1, qualifier, Permission.Action.READ); assertFalse("User should not be granted permission: " + up.toString(), hasFoundUserPermission(up, perms)); grantOnTable(TEST_UTIL, user.getShortName(), tableName, family1, qualifier, Permission.Action.READ); acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel service = acl.coprocessorService(tableName.getName()); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(service); perms = ProtobufUtil.getUserPermissions(protocol, tableName); } finally { acl.close(); } UserPermission upToVerify = new UserPermission( userName, tableName, family1, qualifier, Permission.Action.READ); assertTrue("User should be granted permission: " + upToVerify.toString(), hasFoundUserPermission(upToVerify, perms)); upToVerify = new UserPermission( userName, tableName, family1, qualifier, Permission.Action.WRITE); assertFalse("User should not be granted permission: " + upToVerify.toString(), hasFoundUserPermission(upToVerify, perms)); grantOnTable(TEST_UTIL, user.getShortName(), tableName, family1, qualifier, Permission.Action.WRITE, Permission.Action.READ); acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel service = acl.coprocessorService(tableName.getName()); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(service); perms = ProtobufUtil.getUserPermissions(protocol, tableName); } finally { acl.close(); } upToVerify = new UserPermission(userName, tableName, family1, qualifier, Permission.Action.WRITE, Permission.Action.READ); assertTrue("User should be granted permission: " + upToVerify.toString(), hasFoundUserPermission(upToVerify, perms)); revokeFromTable(TEST_UTIL, user.getShortName(), tableName, family1, qualifier, Permission.Action.WRITE, Permission.Action.READ); acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel service = acl.coprocessorService(tableName.getName()); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(service); perms = ProtobufUtil.getUserPermissions(protocol, tableName); } finally { acl.close(); } assertFalse("User should not be granted permission: " + upToVerify.toString(), hasFoundUserPermission(upToVerify, perms)); admin.disableTable(tableName); User newOwner = User.createUserForTesting(conf, "new_owner", new String[] {}); htd.setOwner(newOwner); admin.modifyTable(tableName, htd); acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel service = acl.coprocessorService(tableName.getName()); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(service); perms = ProtobufUtil.getUserPermissions(protocol, tableName); } finally { acl.close(); } UserPermission newOwnerperm = new UserPermission( Bytes.toBytes(newOwner.getName()), tableName, null, Action.values()); assertTrue("New owner should have all permissions on table", hasFoundUserPermission(newOwnerperm, perms)); admin.deleteTable(tableName); } @Test public void testGlobalPermissionList() throws Exception { List<UserPermission> perms; HTable acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel service = acl.coprocessorService(HConstants.EMPTY_START_ROW); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(service); perms = ProtobufUtil.getUserPermissions(protocol); } finally { acl.close(); } UserPermission adminPerm = new UserPermission(Bytes.toBytes(USER_ADMIN.getShortName()), AccessControlLists.ACL_TABLE_NAME, null, null, Bytes.toBytes("ACRW")); assertTrue("Only user admin has permission on table _acl_ per setup", perms.size() == 1 && hasFoundUserPermission(adminPerm, perms)); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void checkPermissions(RpcController controller, AccessControlProtos.CheckPermissionsRequest request, RpcCallback<AccessControlProtos.CheckPermissionsResponse> done) { Permission[] permissions = new Permission[request.getPermissionCount()]; for (int i=0; i < request.getPermissionCount(); i++) { permissions[i] = ProtobufUtil.toPermission(request.getPermission(i)); } AccessControlProtos.CheckPermissionsResponse response = null; try { TableName tableName = regionEnv.getRegion().getTableDesc().getTableName(); for (Permission permission : permissions) { if (permission instanceof TablePermission) { TablePermission tperm = (TablePermission) permission; for (Action action : permission.getActions()) { if (!tperm.getTableName().equals(tableName)) { throw new CoprocessorException(AccessController.class, String.format("This method " + "can only execute at the table specified in TablePermission. " + "Table of the region:%s , requested table:%s", tableName, tperm.getTableName())); } Map<byte[], Set<byte[]>> familyMap = new TreeMap<byte[], Set<byte[]>>(Bytes.BYTES_COMPARATOR); if (tperm.getFamily() != null) { if (tperm.getQualifier() != null) { Set<byte[]> qualifiers = Sets.newTreeSet(Bytes.BYTES_COMPARATOR); qualifiers.add(tperm.getQualifier()); familyMap.put(tperm.getFamily(), qualifiers); } else { familyMap.put(tperm.getFamily(), null); } } requirePermission("checkPermissions", action, regionEnv, familyMap); } } else { for (Action action : permission.getActions()) { requirePermission("checkPermissions", action); } } } response = AccessControlProtos.CheckPermissionsResponse.getDefaultInstance(); } catch (IOException ioe) { ResponseConverter.setControllerException(controller, ioe); } done.run(response); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testCheckPermissions() throws Exception { AccessTestAction globalAdmin = new AccessTestAction() { @Override public Void run() throws Exception { checkGlobalPerms(Permission.Action.ADMIN); return null; } }; verifyGlobal(globalAdmin); AccessTestAction globalReadWrite = new AccessTestAction() { @Override public Void run() throws Exception { checkGlobalPerms(Permission.Action.READ, Permission.Action.WRITE); return null; } }; verifyGlobal(globalReadWrite); final byte[] TEST_Q1 = Bytes.toBytes("q1"); final byte[] TEST_Q2 = Bytes.toBytes("q2"); User userTable = User.createUserForTesting(conf, "user_check_perms_table", new String[0]); User userColumn = User.createUserForTesting(conf, "user_check_perms_family", new String[0]); User userQualifier = User.createUserForTesting(conf, "user_check_perms_q", new String[0]); grantOnTable(TEST_UTIL, userTable.getShortName(), TEST_TABLE.getTableName(), null, null, Permission.Action.READ); grantOnTable(TEST_UTIL, userColumn.getShortName(), TEST_TABLE.getTableName(), TEST_FAMILY, null, Permission.Action.READ); grantOnTable(TEST_UTIL, userQualifier.getShortName(), TEST_TABLE.getTableName(), TEST_FAMILY, TEST_Q1, Permission.Action.READ); AccessTestAction tableRead = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), null, null, Permission.Action.READ); return null; } }; AccessTestAction columnRead = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), TEST_FAMILY, null, Permission.Action.READ); return null; } }; AccessTestAction qualifierRead = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), TEST_FAMILY, TEST_Q1, Permission.Action.READ); return null; } }; AccessTestAction multiQualifierRead = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), new Permission[] { new TablePermission(TEST_TABLE.getTableName(), TEST_FAMILY, TEST_Q1, Permission.Action.READ), new TablePermission(TEST_TABLE.getTableName(), TEST_FAMILY, TEST_Q2, Permission.Action.READ), }); return null; } }; AccessTestAction globalAndTableRead = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), new Permission[] { new Permission(Permission.Action.READ), new TablePermission(TEST_TABLE.getTableName(), null, (byte[]) null, Permission.Action.READ), }); return null; } }; AccessTestAction noCheck = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), new Permission[0]); return null; } }; verifyAllowed(tableRead, SUPERUSER, userTable); verifyDenied(tableRead, userColumn, userQualifier); verifyAllowed(columnRead, SUPERUSER, userTable, userColumn); verifyDenied(columnRead, userQualifier); verifyAllowed(qualifierRead, SUPERUSER, userTable, userColumn, userQualifier); verifyAllowed(multiQualifierRead, SUPERUSER, userTable, userColumn); verifyDenied(multiQualifierRead, userQualifier); verifyAllowed(globalAndTableRead, SUPERUSER); verifyDenied(globalAndTableRead, userTable, userColumn, userQualifier); verifyAllowed(noCheck, SUPERUSER, userTable, userColumn, userQualifier); AccessTestAction familyReadWrite = new AccessTestAction() { @Override public Void run() throws Exception { checkTablePerms(TEST_TABLE.getTableName(), TEST_FAMILY, null, Permission.Action.READ, Permission.Action.WRITE); return null; } }; verifyAllowed(familyReadWrite, SUPERUSER, USER_OWNER, USER_CREATE, USER_RW); verifyDenied(familyReadWrite, USER_NONE, USER_RO); CheckPermissionsRequest checkRequest = CheckPermissionsRequest.newBuilder() .addPermission(AccessControlProtos.Permission.newBuilder() .setType(AccessControlProtos.Permission.Type.Table) .setTablePermission( AccessControlProtos.TablePermission.newBuilder() .setTableName(ProtobufUtil.toProtoTableName(TEST_TABLE.getTableName())) .addAction(AccessControlProtos.Permission.Action.CREATE)) ).build(); HTable acl = new HTable(conf, AccessControlLists.ACL_TABLE_NAME); try { BlockingRpcChannel channel = acl.coprocessorService(new byte[0]); AccessControlService.BlockingInterface protocol = AccessControlService.newBlockingStub(channel); try { protocol.checkPermissions(null, checkRequest); fail("this should have thrown CoprocessorException"); } catch (ServiceException ex) { } } finally { acl.close(); } }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preStopRegionServer( ObserverContext<RegionServerCoprocessorEnvironment> env) throws IOException { requirePermission("preStopRegionServer", Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testStopRegionServer() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preStopRegionServer(ObserverContext.createAndPrepare(RSCP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN); verifyDenied(action, USER_CREATE, USER_OWNER, USER_RW, USER_RO, USER_NONE); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preOpen(ObserverContext<RegionCoprocessorEnvironment> e) throws IOException { RegionCoprocessorEnvironment env = e.getEnvironment(); final HRegion region = env.getRegion(); if (region == null) { LOG.error("NULL region from RegionCoprocessorEnvironment in preOpen()"); } else { HRegionInfo regionInfo = region.getRegionInfo(); if (regionInfo.getTable().isSystemTable()) { isSystemOrSuperUser(regionEnv.getConfiguration()); } else { requirePermission("preOpen", Action.ADMIN); } } } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testOpenRegion() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preOpen(ObserverContext.createAndPrepare(RCP_ENV, null)); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_OWNER); }
AccessController extends BaseRegionObserver implements MasterObserver, RegionServerObserver, AccessControlService.Interface, CoprocessorService, EndpointObserver { @Override public void preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested) throws IOException { requirePermission("preClose", Action.ADMIN); } HRegion getRegion(); TableAuthManager getAuthManager(); void start(CoprocessorEnvironment env); void stop(CoprocessorEnvironment env); @Override void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions); @Override void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd); @Override void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column); @Override void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor); @Override void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col); @Override void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName); @Override void preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void postMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer); @Override void preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void postUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force); @Override void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo); @Override void preBalance(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postBalance(ObserverContext<MasterCoprocessorEnvironment> c, List<RegionPlan> plans); @Override boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue); @Override void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean oldValue, boolean newValue); @Override void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c); @Override void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c); @Override void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preMasterInitialization( ObserverContext<MasterCoprocessorEnvironment> ctx); @Override void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void postCloneSnapshot(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 postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor); @Override void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, final SnapshotDescription snapshot); @Override void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace); @Override void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns); @Override void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, final TableName tableName); @Override void postTableFlush(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 preCompactSelection(final ObserverContext<RegionCoprocessorEnvironment> e, final Store store, final List<StoreFile> candidates); @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 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 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 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 preIncrement(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); void prePrepareBulkLoad(RegionCoprocessorEnvironment e); void preCleanupBulkLoad(RegionCoprocessorEnvironment e); @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); @Override void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors); @Override void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries); @Override void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion); @Override void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); @Override void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB); static final Log LOG; }	@Test public void testCloseRegion() throws Exception { AccessTestAction action = new AccessTestAction() { @Override public Object run() throws Exception { ACCESS_CONTROLLER.preClose(ObserverContext.createAndPrepare(RCP_ENV, null), false); return null; } }; verifyAllowed(action, SUPERUSER, USER_ADMIN); verifyDenied(action, USER_CREATE, USER_RW, USER_RO, USER_NONE, USER_OWNER); }
Parallels { public static <T> void runEach(final Iterable<T> elements, final Action1<T> action) { shouldNotBeNull(elements, "elements"); shouldNotBeNull(action, "function"); if (isDebugEnabled) log.debug("병렬로 작업을 수행합니다... workerCount=[{}]", getWorkerCount()); ExecutorService executor = Executors.newFixedThreadPool(getWorkerCount()); try { List<T> elemList = Lists.newArrayList(elements); int partitionSize = getPartitionSize(elemList.size(), getWorkerCount()); Iterable<List<T>> partitions = Iterables.partition(elemList, partitionSize); List<Callable<Void>> tasks = Lists.newLinkedList(); for (final List<T> partition : partitions) { Callable<Void> task = new Callable<Void>() { @Override public Void call() throws Exception { for (final T element : partition) action.perform(element); return null; } }; tasks.add(task); } List<Future<Void>> results = executor.invokeAll(tasks); for (Future<Void> result : results) { result.get(); } if (isDebugEnabled) log.debug("모든 작업을 병렬로 수행하였습니다. workerCount=[{}]", getWorkerCount()); } catch (Exception e) { log.error("데이터에 대한 병렬 작업 중 예외가 발생했습니다.", e); throw new RuntimeException(e); } finally { executor.shutdown(); } } private Parallels(); static ExecutorService createExecutor(); static ExecutorService createExecutor(int threadCount); static void run(int count, final Runnable runnable); static void run(int fromInclude, int toExclude, final Runnable action); static void run(int fromInclude, int toExclude, int step, final Runnable runnable); static void run(int count, final Action1<Integer> action); static void run(int fromInclude, int toExclude, final Action1<Integer> action); static void run(int fromInclude, int toExclude, int step, final Action1<Integer> action); static List<V> run(int count, final Callable<V> callable); static List<V> run(int fromInclude, int toExclude, final Callable<V> callable); static List<V> run(int fromInclude, int toExclude, int step, final Callable<V> callable); static List<V> run(int count, final Function1<Integer, V> function); static List<V> run(int fromInclude, int toExclude, final Function1<Integer, V> function); static List<V> run(int fromInclude, int toExclude, int step, final Function1<Integer, V> function); static void runEach(final Iterable<T> elements, final Action1<T> action); static List<V> runEach(final Iterable<T> elements, final Function1<T, V> function); static void runPartitions(int count, final Action1<List<Integer>> action); static void runPartitions(int fromInclude, int toExclude, final Action1<List<Integer>> action); static void runPartitions(int fromInclude, int toExclude, int step, final Action1<List<Integer>> action); static List<V> runPartitions(int count, final Function1<List<Integer>, List<V>> function); static List<V> runPartitions(int fromInclude, int toExclude, final Function1<List<Integer>, List<V>> function); static List<V> runPartitions(int fromInclude, int toExclude, int step, final Function1<List<Integer>, List<V>> function); static void runPartitions(final Iterable<T> elements, final Action1<List<T>> action); static List<V> runPartitions(final Iterable<T> elements, final Function1<List<T>, List<V>> function); }	@Test public void parallelRunEachAction() { final Action1<Integer> action1 = new Action1<Integer>() { @Override public void perform(Integer x) { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); } }; @Cleanup AutoStopwatch stopwatch = new AutoStopwatch(); Parallels.runEach(NumberRange.range(0, 100), action1); } @Test public void parallelRunEachFunction() { final Function1<Integer, Double> function1 = new Function1<Integer, Double>() { @Override public Double execute(Integer x) { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); return Hero.findRoot(UpperBound); } }; try (AutoStopwatch stopwatch = new AutoStopwatch()) { List<Double> results = Parallels.runEach(NumberRange.range(0, 100), function1); Assert.assertNotNull(results); Assert.assertEquals(100, results.size()); } }
Parallels { public static void run(int count, final Runnable runnable) { run(0, count, runnable); } private Parallels(); static ExecutorService createExecutor(); static ExecutorService createExecutor(int threadCount); static void run(int count, final Runnable runnable); static void run(int fromInclude, int toExclude, final Runnable action); static void run(int fromInclude, int toExclude, int step, final Runnable runnable); static void run(int count, final Action1<Integer> action); static void run(int fromInclude, int toExclude, final Action1<Integer> action); static void run(int fromInclude, int toExclude, int step, final Action1<Integer> action); static List<V> run(int count, final Callable<V> callable); static List<V> run(int fromInclude, int toExclude, final Callable<V> callable); static List<V> run(int fromInclude, int toExclude, int step, final Callable<V> callable); static List<V> run(int count, final Function1<Integer, V> function); static List<V> run(int fromInclude, int toExclude, final Function1<Integer, V> function); static List<V> run(int fromInclude, int toExclude, int step, final Function1<Integer, V> function); static void runEach(final Iterable<T> elements, final Action1<T> action); static List<V> runEach(final Iterable<T> elements, final Function1<T, V> function); static void runPartitions(int count, final Action1<List<Integer>> action); static void runPartitions(int fromInclude, int toExclude, final Action1<List<Integer>> action); static void runPartitions(int fromInclude, int toExclude, int step, final Action1<List<Integer>> action); static List<V> runPartitions(int count, final Function1<List<Integer>, List<V>> function); static List<V> runPartitions(int fromInclude, int toExclude, final Function1<List<Integer>, List<V>> function); static List<V> runPartitions(int fromInclude, int toExclude, int step, final Function1<List<Integer>, List<V>> function); static void runPartitions(final Iterable<T> elements, final Action1<List<T>> action); static List<V> runPartitions(final Iterable<T> elements, final Function1<List<T>, List<V>> function); }	@Test public void parallelCallable() { final Callable<Double> callable = new Callable<Double>() { @Override public Double call() { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); return Hero.findRoot(UpperBound); } }; @Cleanup AutoStopwatch stopwatch = new AutoStopwatch(); List<Double> results = Parallels.run(0, 100, callable); Assert.assertNotNull(results); Assert.assertEquals(100, results.size()); } @Test public void parallelRunFunction() { final Function1<Integer, Double> function1 = new Function1<Integer, Double>() { @Override public Double execute(Integer x) { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); return Hero.findRoot(UpperBound); } }; @Cleanup AutoStopwatch stopwatch = new AutoStopwatch(); List<Double> results = Parallels.run(0, 100, function1); Assert.assertNotNull(results); Assert.assertEquals(100, results.size()); } @Test public void parallelRunnable() { final Runnable runnable = new Runnable() { @Override public void run() { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); } }; @Cleanup AutoStopwatch stopwatch = new AutoStopwatch(); Parallels.run(0, 100, runnable); } @Test public void parallelRunAction() { final Action1<Integer> action1 = new Action1<Integer>() { @Override public void perform(Integer x) { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); } }; try (AutoStopwatch stopwatch = new AutoStopwatch()) { Parallels.run(0, 100, action1); } }
Parallels { public static void runPartitions(int count, final Action1<List<Integer>> action) { runPartitions(0, count, action); } private Parallels(); static ExecutorService createExecutor(); static ExecutorService createExecutor(int threadCount); static void run(int count, final Runnable runnable); static void run(int fromInclude, int toExclude, final Runnable action); static void run(int fromInclude, int toExclude, int step, final Runnable runnable); static void run(int count, final Action1<Integer> action); static void run(int fromInclude, int toExclude, final Action1<Integer> action); static void run(int fromInclude, int toExclude, int step, final Action1<Integer> action); static List<V> run(int count, final Callable<V> callable); static List<V> run(int fromInclude, int toExclude, final Callable<V> callable); static List<V> run(int fromInclude, int toExclude, int step, final Callable<V> callable); static List<V> run(int count, final Function1<Integer, V> function); static List<V> run(int fromInclude, int toExclude, final Function1<Integer, V> function); static List<V> run(int fromInclude, int toExclude, int step, final Function1<Integer, V> function); static void runEach(final Iterable<T> elements, final Action1<T> action); static List<V> runEach(final Iterable<T> elements, final Function1<T, V> function); static void runPartitions(int count, final Action1<List<Integer>> action); static void runPartitions(int fromInclude, int toExclude, final Action1<List<Integer>> action); static void runPartitions(int fromInclude, int toExclude, int step, final Action1<List<Integer>> action); static List<V> runPartitions(int count, final Function1<List<Integer>, List<V>> function); static List<V> runPartitions(int fromInclude, int toExclude, final Function1<List<Integer>, List<V>> function); static List<V> runPartitions(int fromInclude, int toExclude, int step, final Function1<List<Integer>, List<V>> function); static void runPartitions(final Iterable<T> elements, final Action1<List<T>> action); static List<V> runPartitions(final Iterable<T> elements, final Function1<List<T>, List<V>> function); }	@Test public void runPartitionsAction() throws Exception { final Action1<List<Integer>> action1 = new Action1<List<Integer>>() { @Override public void perform(List<Integer> xs) { for (int x : xs) { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); } } }; @Cleanup AutoStopwatch stopwatch = new AutoStopwatch(); Parallels.runPartitions(NumberRange.range(0, 100), action1); } @Test public void runPartitionsFunction() { final Function1<List<Integer>, List<Double>> function1 = new Function1<List<Integer>, List<Double>>() { @Override public List<Double> execute(List<Integer> xs) { List<Double> results = Lists.newArrayListWithCapacity(xs.size()); for (int x : xs) { for (int i = LowerBound; i < UpperBound; i++) { Hero.findRoot(i); } if (log.isDebugEnabled()) log.debug("FindRoot({}) returns [{}]", UpperBound, Hero.findRoot(UpperBound)); results.add(Hero.findRoot(UpperBound)); } return results; } }; @Cleanup AutoStopwatch stopwatch = new AutoStopwatch(); List<Double> results = Parallels.runPartitions(NumberRange.range(0, 100), function1); Assert.assertNotNull(results); Assert.assertEquals(100, results.size()); }
Activators { public static Object createInstance(String className) { log.trace("create instance... className=[{}]", className); try { return createInstance(Class.forName(className)); } catch (Exception e) { throw new RuntimeException(e); } } private Activators(); static Object createInstance(String className); static T createInstance(Class<T> clazz); @SuppressWarnings("unchecked") static T createInstance(Class<T> clazz, Object... initArgs); static Constructor<T> getConstructor(Class<T> clazz, Class<?>... parameterTypes); }	@BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void createInstanceWithDefaultConstructor() { JClass obj = Activators.createInstance(JClass.class); Assert.assertNotNull(obj); Assert.assertEquals(0, obj.getId()); } @BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void crateInstanceWithParameters() { JClass obj = Activators.createInstance(JClass.class, 100, "Dynamic", 200); Assert.assertNotNull(obj); Assert.assertEquals(100, obj.getId()); Assert.assertEquals("Dynamic", obj.getName()); }
Activators { public static <T> Constructor<T> getConstructor(Class<T> clazz, Class<?>... parameterTypes) { log.trace("[{}] 수형의 생성자를 구합니다. parameterTypes=[{}]", clazz.getName(), StringTool.listToString(parameterTypes)); try { return clazz.getDeclaredConstructor(parameterTypes); } catch (Exception e) { throw new RuntimeException(e); } } private Activators(); static Object createInstance(String className); static T createInstance(Class<T> clazz); @SuppressWarnings("unchecked") static T createInstance(Class<T> clazz, Object... initArgs); static Constructor<T> getConstructor(Class<T> clazz, Class<?>... parameterTypes); }	@BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void crateInstanceWithParameterTypes() throws Exception { JClass obj = (JClass) Activators .getConstructor(JClass.class, Integer.TYPE, String.class, Integer.class) .newInstance(100, "Dynamic", 200); Assert.assertNotNull(obj); Assert.assertEquals(100, obj.getId()); Assert.assertEquals("Dynamic", obj.getName()); } @BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void reflectionsWithDefaultConstructor() { try { JClass obj = (JClass) JClass.class .getConstructor(Integer.TYPE, String.class, Integer.class) .newInstance(100, "Dynamic", 200); Assert.assertNotNull(obj); Assert.assertEquals(100, obj.getId()); Assert.assertEquals("Dynamic", obj.getName()); } catch (Exception e) { throw new RuntimeException(e); } }
DynamicAccessorFactory { @SuppressWarnings("unchecked") public static <T> DynamicAccessor<T> create(Class<T> targetType) { try { return (DynamicAccessor<T>) cache.get(targetType); } catch (ExecutionException e) { log.error("DynamicAccessor 를 생성하는데 실패했습니다. targetType=" + targetType.getName(), e); return null; } } @SuppressWarnings("unchecked") static DynamicAccessor<T> create(Class<T> targetType); static synchronized void clear(); }	@BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void createDynamicAccessor() { DynamicAccessor<User> userAccessor = DynamicAccessorFactory.create(User.class); Assert.assertNotNull(userAccessor); Object user = userAccessor.newInstance(); userAccessor.setProperty(user, "email", "[email protected]"); Assert.assertEquals("[email protected]", userAccessor.getProperty(user, "email")); }
CryptoTool { public static byte[] getRandomBytes(final int numBytes) { assert (numBytes >= 0); byte[] bytes = new byte[numBytes]; if (numBytes > 0) random.nextBytes(bytes); return bytes; } private CryptoTool(); static byte[] getRandomBytes(final int numBytes); }	@Test public void getRandomBytesTest() throws Exception { byte[] bytes = CryptoTool.getRandomBytes(100); byte[] bytes2 = CryptoTool.getRandomBytes(100); Assert.assertEquals(bytes.length, bytes2.length); Assert.assertFalse(Arrays.equals(bytes, bytes2)); }
FutureWebCacheRepository extends CacheRepositoryBase { @Override public Object get(final String key) throws ExecutionException { return cache.get(key); } FutureWebCacheRepository(); @Override Object get(final String key); @Override void set(final String key, final Object value, long validFor); @Override void remove(final String key); @Override void removeAll(final String... keys); @Override void removeAll(final Iterable<String> keys); @Override boolean exists(final String key); @Override void clear(); }	@Test public void webCacheRepositoryTest() throws Exception { FutureWebCacheRepository repository = new FutureWebCacheRepository(); Stopwatch stopwatch = new Stopwatch(); for (final String url : urls) { stopwatch.start(); repository.get(url); stopwatch.stop(); log.debug("First: " + stopwatch.toString()); stopwatch.start(); repository.get(url); stopwatch.stop(); log.debug("Second: " + stopwatch.toString()); } }
NumberRange implements Iterable<T> { public static IntRange range(int fromInclude, int toExclude, int step) { return new IntRange(fromInclude, toExclude, step); } private NumberRange(); static IntRange range(int fromInclude, int toExclude, int step); static IntRange range(int fromInclude, int toExclude); static IntRange range(int count); static LongRange range(long fromInclude, long toExclude, long step); static LongRange range(long fromInclude, long toExclude); static LongRange range(long count); static List<IntRange> partition(IntRange range, int partitionCount); static List<IntRange> partition(int fromInclude, int toExclude, int step, int partitionCount); static List<IntRange> partition(int fromInclude, int toExclude, int partitionCount); static List<IntRange> partition(int count, int partitionCount); static List<LongRange> partition(LongRange range, int partitionCount); static List<LongRange> partition(long fromInclude, long toExclude, int step, int partitionCount); static List<LongRange> partition(long fromInclude, long toExclude, int partitionCount); static List<LongRange> partition(long count, int partitionCount); }	@Test public void createIntRange() { NumberRange.IntRange intRange = NumberRange.range(10); assertEquals(0, intRange.getFromInclude()); assertEquals(10, intRange.getToExclude()); assertEquals(1, intRange.getStep()); assertEquals(10, intRange.size()); log.debug(StringTool.join(intRange, ",")); intRange.reset(); for (int x : intRange) System.out.print(x + ", "); }
NumberRange implements Iterable<T> { public static List<IntRange> partition(IntRange range, int partitionCount) { if (isTraceEnabled) log.trace("partition... range=[{}], partitionCount=[{}]", range, partitionCount); int rangeSize = range.size(); int stepSign = range.getStep(); int step = range.getStep(); int partitionSize = rangeSize / partitionCount; int remainder = rangeSize % partitionCount; List<IntRange> partitions = Lists.newLinkedList(); int fromInclude = range.fromInclude; for (int i = 0; i < partitionCount; i++) { int toExclude = fromInclude + (partitionSize + ((remainder > 0) ? 1 : 0)) * stepSign; if (remainder > 0) remainder--; toExclude = (step > 0) ? Math.min(toExclude, range.getToExclude()) : Math.max(toExclude, range.getToExclude()); IntRange partition = range(fromInclude, toExclude, step); partitions.add(partition); fromInclude = toExclude; if (isTraceEnabled) log.trace("Partition 추가 = [{}]", partition); } return partitions; } private NumberRange(); static IntRange range(int fromInclude, int toExclude, int step); static IntRange range(int fromInclude, int toExclude); static IntRange range(int count); static LongRange range(long fromInclude, long toExclude, long step); static LongRange range(long fromInclude, long toExclude); static LongRange range(long count); static List<IntRange> partition(IntRange range, int partitionCount); static List<IntRange> partition(int fromInclude, int toExclude, int step, int partitionCount); static List<IntRange> partition(int fromInclude, int toExclude, int partitionCount); static List<IntRange> partition(int count, int partitionCount); static List<LongRange> partition(LongRange range, int partitionCount); static List<LongRange> partition(long fromInclude, long toExclude, int step, int partitionCount); static List<LongRange> partition(long fromInclude, long toExclude, int partitionCount); static List<LongRange> partition(long count, int partitionCount); }	@Test public void createIntPartition() { int from = 0; int to = 100; int partitionCount = 4; int partitionSize = (to - from) / partitionCount + ((to - from) % partitionCount > 0 ? 1 : 0); List<NumberRange.IntRange> ranges = NumberRange.partition(from, to, partitionCount); assertEquals(4, ranges.size()); for (int i = 0; i < partitionCount; i++) { NumberRange.IntRange intRange = ranges.get(i); assertEquals(from + i * partitionSize, intRange.getFromInclude()); assertEquals(from + (i + 1) * partitionSize, intRange.getToExclude()); assertEquals(1, intRange.getStep()); assertEquals(partitionSize, intRange.size()); } } @Test public void createIntPartitionUnnormal() { int from = 0; int to = 102; int partitionCount = 4; int partitionSize = (to - from) / partitionCount; List<NumberRange.IntRange> ranges = NumberRange.partition(from, to, partitionCount); assertEquals(4, ranges.size()); List<int[]> expectedList = Lists.newArrayList( new int[] { 0, 26, 1, 26 }, new int[] { 26, 52, 1, 26 }, new int[] { 52, 77, 1, 25 }, new int[] { 77, 102, 1, 25 }); for (int i = 0; i < partitionCount; i++) { NumberRange.IntRange intRange = ranges.get(i); int[] expected = expectedList.get(i); if (log.isDebugEnabled()) log.debug("NumberRange({})=[{}]", i, intRange); assertEquals(expected[0], intRange.getFromInclude()); assertEquals(expected[1], intRange.getToExclude()); assertEquals(expected[2], intRange.getStep()); assertEquals(expected[3], intRange.size()); } } @Test public void createIntPartitionUnnormalInverse() { int from = 102; int to = 0; int partitionCount = 4; int partitionSize = (to - from) / partitionCount; List<NumberRange.IntRange> ranges = NumberRange.partition(from, to, partitionCount); assertEquals(4, ranges.size()); List<int[]> expectedList = Lists.newArrayList( new int[] { 102, 76, -1, 26 }, new int[] { 76, 50, -1, 26 }, new int[] { 50, 25, -1, 25 }, new int[] { 25, 0, -1, 25 }); for (int i = 0; i < partitionCount; i++) { NumberRange.IntRange intRange = ranges.get(i); int[] expected = expectedList.get(i); if (log.isDebugEnabled()) log.debug("NumberRange({})=[{}]", i, intRange); assertEquals(expected[0], intRange.getFromInclude()); assertEquals(expected[1], intRange.getToExclude()); assertEquals(expected[2], intRange.getStep()); assertEquals(expected[3], intRange.size()); } }
HibernateOgmDao implements IHibernateOgmDao { @Override public void deleteById(Class<?> clazz, Serializable id) { Object entity = getFullTextSession().load(clazz, id); delete(entity); } @Override synchronized final Session getSession(); @Override synchronized final FullTextSession getFullTextSession(); @Override final QueryBuilder getQueryBuilder(Class<?> clazz); @Override FullTextQuery getFullTextQuery(Query luceneQuery, Class<?>... entities); @Override T get(Class<T> clazz, Serializable id); @Override List<T> find(Class<T> clazz); @Override List<T> find(Class<T> clazz, Query luceneQuery); @Override List<T> find(Class<T> clazz, Query luceneQuery, Sort luceneSort); @Override List<T> find(Class<T> clazz, Query luceneQuery, int firstResult, int maxResults, Sort luceneSort); @Override List<T> find(Class<T> clazz, Query luceneQuery, int firstResult, int maxResults, Sort luceneSort, Criteria criteria); @Override List<Serializable> findIds(Class<?> clazz, Query luceneQuery); @Override List<Serializable> findIds(Class<?> clazz, Query luceneQuery, int firstResult, int maxResults, Sort luceneSort); @Override List<Serializable> findIds(Class<?> clazz, Query luceneQuery, int firstResult, int maxResults, Sort luceneSort, Criteria criteria); @Override List<Object[]> findProjections(Class<?> clazz, Query luceneQuery, String[] fields); @Override List<Object[]> findProjections(Class<?> clazz, Query luceneQuery, String[] fields, Sort luceneSort); @Override List<Object[]> findProjections(Class<?> clazz, Query luceneQuery, String[] fields, Sort luceneSort, Criteria criteria); @Override List<Object[]> findProjections(Class<?> clazz, Query luceneQuery, String[] fields, int firstResult, int maxResults, Sort luceneSort, Criteria criteria); @Override IPagedList<T> getPage(Class<T> clazz, Query luceneQuery, int pageNo, int pageSize); @Override IPagedList<T> getPage(Class<T> clazz, Query luceneQuery, int pageNo, int pageSize, Sort luceneSort); @Override IPagedList<T> getPage(Class<T> clazz, Query luceneQuery, int pageNo, int pageSize, Sort luceneSort, Criteria criteria); @Override IPagedList<Serializable> getIdPage(Class<?> clazz, Query luceneQuery, int pageNo, int pageSize); @Override IPagedList<Serializable> getIdPage(Class<?> clazz, Query luceneQuery, int pageNo, int pageSize, Sort luceneSort); @Override IPagedList<Serializable> getIdPage(Class<?> clazz, Query luceneQuery, int pageNo, int pageSize, Sort luceneSort, Criteria criteria); @Override IPagedList<Object[]> getProjectionPage(Class<?> clazz, Query luceneQuery, String[] fields, int pageNo, int pageSize); @Override IPagedList<Object[]> getProjectionPage(Class<?> clazz, Query luceneQuery, String[] fields, int pageNo, int pageSize, Sort luceneSort); @Override IPagedList<Object[]> getProjectionPage(Class<?> clazz, Query luceneQuery, String[] fields, int pageNo, int pageSize, Sort luceneSort, Criteria criteria); @Override long count(Class<?> clazz); @Override long count(Class<?> clazz, Query luceneQuery); @Override long count(Class<?> clazz, Query luceneQuery, Criteria criteria); @Override boolean exists(Class<?> clazz); @Override boolean exists(Class<?> clazz, Query luceneQuery); @Override void persist(Object entity); @Override Object merge(Object entity); @Override Serializable save(Object entity); @Override void saveOrUpdate(Object entity); @Override void update(Object entity); @Override void delete(Object entity); @Override void deleteById(Class<?> clazz, Serializable id); @Override void deleteByIds(Class<?> clazz, Collection<? extends Serializable> ids); @Override void deleteAll(Class<?> clazz); @Override void deleteAll(Class<?> clazz, Query luceneQuery); @Override void deleteAll(Collection<?> entities); @Override void purge(Class<?> clazz, Serializable id); @Override void purgeAll(Class<?> clazz); @Override void flushToIndexes(); @Override void index(T entity); @Override void indexAll(Class<?> clazz, int batchSize); @Override Future<Void> indexAllAsync(final Class<?> clazz, final int batchSize); @Override void clearIndex(Class<?> clazz); @Override void clearIndexAll(); @Override void optimize(Class<?> clazz); @Override void optimizeAll(); @Override void flush(); @Override void flushIndexes(); }	@Test public void deleteByIdTest() throws Exception { Player player = createPlayer(); dao.saveOrUpdate(player); UnitOfWorks.getCurrent().transactionalFlush(); UnitOfWorks.getCurrent().clearSession(); dao.deleteById(Player.class, player.getId()); UnitOfWorks.getCurrent().transactionalFlush(); UnitOfWorks.getCurrent().clearSession(); Player loaded = dao.get(Player.class, player.getId()); assertThat(loaded).isNull(); }
MongoCache implements Cache { @Override public void clear() { mongoTemplate.dropCollection(name); } MongoCache(String name, MongoTemplate mongoTemplate); @Override String getName(); @Override Object getNativeCache(); @Override ValueWrapper get(Object key); @Override void put(Object key, Object value); @Override void evict(Object key); @Override void clear(); }	@Test public void clearTest() { Assert.assertNotNull(cacheManager); Cache cache = cacheManager.getCache("user"); Assert.assertNotNull(cache); }
MapperTool { public static <T> T map(final Object source, final Class<T> destinationClass) { shouldNotBeNull(source, "source"); shouldNotBeNull(destinationClass, "destinationClass"); return mapper.map(source, destinationClass); } private MapperTool(); static T map(final Object source, final Class<T> destinationClass); static void map(final Object source, Object destination); static List<T> mapList(final Iterable<S> sources, final Class<T> destinationClass); static Future<T> mapAsync(final Object source, final Class<T> destinationClass); static Future<List<T>> mapListAsync(final Iterable<S> sources, final Class<T> destinationClass); }	@BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void mapTest() { Parent parent = getParentSample(); ParentDTO parentDTO = MapperTool.map(parent, ParentDTO.class); Assert.assertNotNull(parentDTO); Assert.assertEquals(parent.getChildren().size(), parentDTO.getChildren().size()); Assert.assertEquals(parent.getName(), parentDTO.getName()); for (int i = 0; i < parent.getChildren().size(); i++) { Assert.assertEquals(parent.getChildren().get(i).getName(), parentDTO.getChildren().get(i).getName()); Assert.assertEquals(parent.getChildren().get(i).getDescription(), parentDTO.getChildren().get(i).getDescription()); } }
HashTool { public static int compute(final Object... objs) { if (objs == null \|\| objs.length == 0) return NULL_VALUE; int hash = NULL_VALUE; for (Object x : objs) { hash = hash * FACTOR + computeInternal(x); } return hash; } static int compute(final Object... objs); static final int NULL_VALUE; static final int ONE_VALUE; static final int FACTOR; }	@BenchmarkOptions(benchmarkRounds = 100, warmupRounds = 1) @Test public void computeHashTest() { int a = HashTool.compute(1, 2); int b = HashTool.compute(2, 1); assertNotEquals(a, b); assertEquals(a, HashTool.compute(1, 2)); int withNull1 = HashTool.compute(new YearWeek(2013, 1), null); int withNull2 = HashTool.compute(null, new YearWeek(2013, 1)); int withNull3 = HashTool.compute(new YearWeek(2013, 1), null); assertNotEquals(withNull1, withNull2); assertNotEquals(withNull2, withNull3); assertEquals(withNull1, withNull3); }
HiveUtil extends BaseDao { public static boolean isTokDDL(String sql) { if (org.apache.commons.lang3.StringUtils.isEmpty(sql)) { return false; } String tmp = sql.toUpperCase(); if (tmp.startsWith("CREATE") \|\| tmp.startsWith("DROP") \|\| tmp.startsWith("ALTER")) { return true; } return false; } @Override void init(); static String getTmpTableName(int projectId, int execId); static String getORCTmpTableDDL(String dbName, String tableName, List<HqlColumn> hqlColumnList, String localtion); static String getTmpTableDDL(String dbName, String tableName, List<HqlColumn> hqlColumnList, String localtion, String fieldDelimiter, String fileCode); static boolean isTokQuery(String sql); static boolean isTokDDL(String sql); static boolean isLikeShowStm(String sql); HiveService2Client getHiveService2Client(); HiveMetaPoolClient getHiveMetaPoolClient(); HiveService2ConnectionInfo getHiveService2ConnectionInfo(String userName); static final int DEFAULT_QUERY_PROGRESS_THREAD_TIMEOUT; }	@Test public void testDDL() { assertFalse(HiveUtil.isTokDDL("")); assertTrue(HiveUtil.isTokDDL("create table abc")); assertTrue(HiveUtil.isTokDDL("alter table abc")); assertFalse(HiveUtil.isTokDDL("select * from abc")); assertFalse(HiveUtil.isTokDDL(null)); }
Graph { public synchronized int getOutdegree(VK key) { Collection<VK> getNeighborNode = getPostNode(key); if (getNeighborNode == null) { return 0; } return getNeighborNode.size(); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testOutdegree() { construtGraph(); assertEquals(graph.getOutdegree(1), 3); assertEquals(graph.getOutdegree(2), 1); assertEquals(graph.getOutdegree(3), 1); assertEquals(graph.getOutdegree(4), 1); assertEquals(graph.getOutdegree(5), 1); assertEquals(graph.getOutdegree(6), 1); assertEquals(graph.getOutdegree(7), 0); assertEquals(graph.getOutdegree(8), 0); assertEquals(graph.getOutdegree(9), 0); assertEquals(graph.getOutdegree(10), 1); }
Graph { public synchronized int getIndegree(VK key) { Collection<VK> getNeighborNode = getPreNode(key); if (getNeighborNode == null) { return 0; } return getNeighborNode.size(); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testIndegree() { construtGraph(); assertEquals(graph.getIndegree(1), 0); assertEquals(graph.getIndegree(2), 1); assertEquals(graph.getIndegree(3), 1); assertEquals(graph.getIndegree(4), 2); assertEquals(graph.getIndegree(5), 2); assertEquals(graph.getIndegree(6), 1); assertEquals(graph.getIndegree(7), 2); assertEquals(graph.getIndegree(8), 0); assertEquals(graph.getIndegree(9), 0); assertEquals(graph.getIndegree(10), 0); }
Graph { public synchronized Collection<VK> getStartVertex() { return CollectionUtils.subtract(vertices.keySet(), reverseEdges.keySet()); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testStart() { construtGraph(); assertEquals(graph.getStartVertex().size(), 4); assertTrue(graph.getStartVertex().contains(1)); assertTrue(graph.getStartVertex().contains(10)); assertTrue(graph.getStartVertex().contains(8)); assertTrue(graph.getStartVertex().contains(9)); }
Graph { public synchronized Collection<VK> getEndVertex() { return CollectionUtils.subtract(vertices.keySet(), edges.keySet()); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testEnd() { construtGraph(); assertEquals(graph.getEndVertex().size(), 3); assertTrue(graph.getEndVertex().contains(7)); assertTrue(graph.getEndVertex().contains(8)); assertTrue(graph.getEndVertex().contains(9)); }
Graph { public List<VK> broadFirstSearch() throws Exception { List<VK> visit = new ArrayList<>(); Queue<VK> q = new LinkedList<>(); Set<VK> hasVisited = new HashSet<>(); synchronized (this) { for (VK key : getStartVertex()) { q.add(key); hasVisited.add(key); visit.add(key); } while (!q.isEmpty()) { VK key = q.poll(); for (VK postKey : getPostNode(key)) { if (!hasVisited.contains(postKey)) { q.add(postKey); hasVisited.add(postKey); visit.add(postKey); } } } if (visit.size() != getVertexNumber()) { throw new Exception("Broad first search can't search complete."); } } return visit; } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testBroadFirstSearch() { clearAndTest(); graph.addEdge(1, 2, null, true); graph.addEdge(2, 3, null, true); graph.addEdge(3, 4, null, true); graph.addEdge(4, 5, null, true); graph.addEdge(1, 6, null, true); List<Integer> visit = null; try { visit = graph.broadFirstSearch(); assertEquals(visit.size(), 6); assertTrue(visit.get(0) == 1); assertTrue(visit.get(1) == 2); assertTrue(visit.get(2) == 6); assertTrue(visit.get(3) == 3); assertTrue(visit.get(4) == 4); assertTrue(visit.get(5) == 5); } catch (Exception e) { assertTrue(false); } graph.addEdge(7, 8, null, true); try { visit = graph.broadFirstSearch(); assertEquals(visit.size(), 8); assertTrue(visit.get(0) == 1); assertTrue(visit.get(1) == 7); assertTrue(visit.get(2) == 2); assertTrue(visit.get(3) == 6); assertTrue(visit.get(4) == 8); assertTrue(visit.get(5) == 3); assertTrue(visit.get(6) == 4); assertTrue(visit.get(7) == 5); } catch (Exception e) { assertTrue(false); } graph.addEdge(8, 7, null, true); try { visit = graph.broadFirstSearch(); assertTrue(false); } catch (Exception e) { assertTrue(true); } }
Graph { public List<VK> depthFirstSearch() throws Exception { List<VK> visit = new ArrayList<>(); Set<VK> hasVisited = new HashSet<>(); synchronized (this) { for (VK key : getStartVertex()) { depthFirstSearch(key, visit, hasVisited); } if (visit.size() != getVertexNumber()) { throw new Exception("Depth first search can't search complete."); } } return visit; } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testDepthFirstSearch() { graph.addEdge(1, 2, null, true); graph.addEdge(2, 3, null, true); graph.addEdge(3, 4, null, true); graph.addEdge(4, 5, null, true); graph.addEdge(1, 6, null, true); List<Integer> visit = null; try { visit = graph.depthFirstSearch(); assertEquals(visit.size(), 6); assertTrue(visit.get(0) == 1); assertTrue(visit.get(1) == 2); assertTrue(visit.get(2) == 3); assertTrue(visit.get(3) == 4); assertTrue(visit.get(4) == 5); assertTrue(visit.get(5) == 6); } catch (Exception e) { assertTrue(false); } graph.addEdge(2, 7, null, true); try { visit = graph.depthFirstSearch(); assertEquals(visit.size(), 7); assertTrue(visit.get(0) == 1); assertTrue(visit.get(1) == 2); assertTrue(visit.get(2) == 3); assertTrue(visit.get(3) == 4); assertTrue(visit.get(4) == 5); assertTrue(visit.get(5) == 7); assertTrue(visit.get(6) == 6); } catch (Exception e) { assertTrue(false); } graph.addEdge(6, 1, null, true); try { visit = graph.depthFirstSearch(); assertTrue(false); } catch (Exception e) { assertTrue(true); } }
Graph { public List<VK> topologicalSort() throws Exception { Map.Entry<Boolean, List<VK>> entry = topologicalSortImpl(); if (entry.getKey()) { return entry.getValue(); } throw new Exception("Graph has a cycle, can't compute topological sort."); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testTopologicalSort() { clearAndTest(); graph.addEdge(1, 2, null, true); graph.addEdge(1, 6, null, true); graph.addEdge(2, 3, null, true); graph.addEdge(3, 4, null, true); graph.addEdge(3, 6, null, true); graph.addEdge(4, 5, null, true); graph.addEdge(5, 3, null, true); graph.addEdge(5, 6, null, true); graph.addEdge(7, 6, null, true); try { graph.topologicalSort(); assertTrue(false); } catch (Exception e) { assertTrue(true); } graph.removeEdge(3, 4); try { List<Integer> entry = graph.topologicalSort(); List l = entry.subList(0, 3); assertTrue(l.contains(1) && l.contains(7) && l.contains(4)); l = entry.subList(3, 5); assertTrue(l.contains(2) && l.contains(5)); assertTrue(entry.get(5) == 3); assertTrue(entry.get(6) == 6); } catch (Exception e) { assertTrue(false); } }
Graph { public synchronized boolean isConnected() { Queue<VK> q = new LinkedList<>(); Set<VK> hasVisited = new HashSet<>(); Iterator<Map.Entry<VK, VD>> iter = vertices.entrySet().iterator(); if (!iter.hasNext()) { return true; } Map.Entry<VK, VD> entry = iter.next(); VK startKey = entry.getKey(); q.add(startKey); hasVisited.add(startKey); while (!q.isEmpty()) { VK key = q.poll(); for (VK postKey : getPostNode(key)) { if (!hasVisited.contains(postKey)) { q.add(postKey); hasVisited.add(postKey); } } for (VK preKey : getPreNode(key)) { if (!hasVisited.contains(preKey)) { q.add(preKey); hasVisited.add(preKey); } } } return hasVisited.size() == getVertexNumber(); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testIsConnected() { clearAndTest(); assertTrue(graph.isConnected()); graph.addVertex(1, null); assertTrue(graph.isConnected()); graph.addEdge(1, 2, null, true); graph.addEdge(2, 3, null, true); graph.addEdge(3, 4, null, true); assertTrue(graph.isConnected()); graph.addEdge(5, 6, null, true); assertFalse(graph.isConnected()); }
HdfsClient implements Closeable { public void mkdir(String dir) throws HdfsException { mkdir(dir, FsPermission.getDefault()); } private HdfsClient(Configuration conf); static void init(Configuration conf); static HdfsClient getInstance(); void addFile(String fileName, byte[] content, String destPath, boolean isOverwrite); void readFile(String hdfsFile, String localFile, boolean overwrite); byte[] readFile(String hdfsFile); boolean delete(String path, boolean recursive); boolean rename(String path, String destPath); void mkdir(String dir); void mkdir(String dir, FsPermission perm); void setOwner(Path path, String user, String group); void setPermission(Path path, FsPermission perm); void setPermissionThis(Path path, FsPermission perm); boolean copy(String srcPath, String dstPath, boolean deleteSource, boolean overwrite); boolean copyLocalToHdfs(String srcPath, String dstPath, boolean deleteSource, boolean overwrite); boolean copyHdfsToLocal(String srcPath, String dstPath, boolean deleteSource, boolean overwrite); long getFileLength(String filePath); boolean exists(String filePath); FileStatus getFileStatus(String filePath); FileStatus[] listFileStatus(String filePath); ContentSummary getContentSummary(String filePath); String getUrl(); @Override void close(); FsStatus getCapacity(); }	@Test public void testMkdir() { try { hdfsClient.mkdir("/tmp/test-001/2/3/"); assertEquals(hdfsClient.exists("/tmp/test-001/2/3/"), true); } catch (IOException e) { assertTrue(false); } hdfsClient.delete("/tmp/test-001", true); try { assertEquals(hdfsClient.exists("/tmp/test-001"), false); } catch (IOException e) { assertTrue(true); } }
HdfsClient implements Closeable { public boolean copy(String srcPath, String dstPath, boolean deleteSource, boolean overwrite) throws HdfsException { Path srcPathObj = new Path(srcPath); Path dstPathObj = new Path(dstPath); try { return FileUtil.copy(fileSystem, srcPathObj, fileSystem, dstPathObj, deleteSource, overwrite, fileSystem.getConf()); } catch (IOException e) { LOGGER.error("Copy exception", e); throw new HdfsException("Copy exception", e); } } private HdfsClient(Configuration conf); static void init(Configuration conf); static HdfsClient getInstance(); void addFile(String fileName, byte[] content, String destPath, boolean isOverwrite); void readFile(String hdfsFile, String localFile, boolean overwrite); byte[] readFile(String hdfsFile); boolean delete(String path, boolean recursive); boolean rename(String path, String destPath); void mkdir(String dir); void mkdir(String dir, FsPermission perm); void setOwner(Path path, String user, String group); void setPermission(Path path, FsPermission perm); void setPermissionThis(Path path, FsPermission perm); boolean copy(String srcPath, String dstPath, boolean deleteSource, boolean overwrite); boolean copyLocalToHdfs(String srcPath, String dstPath, boolean deleteSource, boolean overwrite); boolean copyHdfsToLocal(String srcPath, String dstPath, boolean deleteSource, boolean overwrite); long getFileLength(String filePath); boolean exists(String filePath); FileStatus getFileStatus(String filePath); FileStatus[] listFileStatus(String filePath); ContentSummary getContentSummary(String filePath); String getUrl(); @Override void close(); FsStatus getCapacity(); }	@Test public void testCopy() throws IOException { PrintWriter writer = new PrintWriter(tmpFilename, "UTF-8"); writer.println("The first line"); writer.println("The second line"); writer.close(); try { assertTrue(hdfsClient.copyLocalToHdfs(tmpFilename, "/tmp", false, true)); assertTrue(hdfsClient.delete(tmpFilename, false)); } catch (HdfsException e) { assertFalse(true); } }
HiveMetaExec { public List<String> getTables(String dbname) throws Exception { HiveMetaStoreClient hiveMetaStoreClient = hiveMetaPoolClient.borrowClient(); try { return hiveMetaStoreClient.getAllTables(dbname); } catch (Exception e) { doWithException(hiveMetaStoreClient, e); throw e; } finally { if (hiveMetaStoreClient != null) { hiveMetaPoolClient.returnClient(hiveMetaStoreClient); } } } HiveMetaExec(Logger logger); List<HqlColumn> getHiveDesc(String dbName, String tableName); List<HqlColumn> checkHiveColumn(List<HiveColumn> srcColumn, List<HqlColumn> destColumn); List<FieldSchema> getPartionField(String dbName, String table); List<FieldSchema> getGeneralField(String dbName, String table); List<String> getTables(String dbname); List<Table> getTableObjectsByName(String dbname); }	@Test public void testGetTables() { try { Logger logger = LoggerFactory.getLogger(HiveMetaExec.class); HiveMetaExec hiveMetaExec = new HiveMetaExec(logger); int times = 100; long start = System.currentTimeMillis(); for (int i = 0; i < times; ++i) { hiveMetaExec.getTables("dw"); } long end = System.currentTimeMillis(); System.out.println("get tables time(ms): " + (end - start) / times); start = System.currentTimeMillis(); for (int i = 0; i < times; ++i) { hiveMetaExec.getTableObjectsByName("dw"); } end = System.currentTimeMillis(); System.out.println("get tables objects time(ms): " + (end - start) / times); } catch (Exception e) { } }
OracleDatasource extends Datasource { @Override public void isConnectable() throws Exception { Connection con = null; try { Class.forName("oracle.jdbc.driver.OracleDriver"); String address = MessageFormat.format("jdbc:oracle:thin:@ con = DriverManager.getConnection(address, this.user, this.password); } finally { if (con != null) { try { con.close(); } catch (SQLException e) { logger.error("Orcale datasource try conn close conn error", e); throw e; } } } } static Logger getLogger(); static void setLogger(Logger logger); String getHost(); void setHost(String host); int getPort(); void setPort(int port); String getService(); void setService(String service); String getUser(); void setUser(String user); String getPassword(); void setPassword(String password); @Override void isConnectable(); }	@Test public void testIsConnectable() throws Exception { OracleDatasource oracleDatasource = new OracleDatasource(); oracleDatasource.setHost("172.18.1.112"); oracleDatasource.setPort(1521); oracleDatasource.setService("orcl"); oracleDatasource.setUser("test"); oracleDatasource.setPassword("test"); oracleDatasource.isConnectable(); }
FtpDatasource extends Datasource { @Override public void isConnectable() throws Exception { FTPClient ftpClient = new FTPClient(); ftpClient.connect(this.host, this.port); if (!ftpClient.login(this.user, this.password)){ throw new Exception("wrong user name or password"); } } String getHost(); void setHost(String host); int getPort(); void setPort(int port); String getUser(); void setUser(String user); String getPassword(); void setPassword(String password); @Override void isConnectable(); }	@Test public void testIsConnectable() throws Exception { }
PostgreDatasource extends Datasource { @Override public void isConnectable() throws Exception { Connection con = null; try { Class.forName("org.postgresql.Driver"); con = DriverManager.getConnection(getJdbcUrl(), this.user, this.password); } finally { if (con != null) { try { con.close(); } catch (SQLException e) { logger.error("Postgre datasource try conn close conn error", e); throw e; } } } } String getAddress(); void setAddress(String address); String getDatabase(); void setDatabase(String database); String getUser(); void setUser(String user); String getPassword(); void setPassword(String password); String getJdbcUrl(); @Override void isConnectable(); }	@Test public void testIsConnectable() throws Exception { PostgreDatasource postgreDatasource = new PostgreDatasource(); postgreDatasource.setAddress("jdbc:postgresql: postgreDatasource.setUser("postgres"); postgreDatasource.setDatabase("test01"); postgreDatasource.setPassword("postgres-2017"); postgreDatasource.isConnectable(); }
BaseParamFactory { public static BaseParam getBaseParam(String type, String parameter) { try { switch (type) { case MR: return JsonUtil.parseObject(parameter, MrParam.class); case SHELL: return JsonUtil.parseObject(parameter, ShellParam.class); case HQL: return JsonUtil.parseObject(parameter, HqlParam.class); case VIRTUAL: return VirtualParam.getInstance(); case SPARK_STREAMING: return JsonUtil.parseObject(parameter, SparkParam.class); case SPARK: return JsonUtil.parseObject(parameter, SparkParam.class); case IMPEXP: return JsonUtil.parseObject(parameter,ImpExpBuilder.class).buildImpExp(); case STORM: return JsonUtil.parseObject(parameter, StormBuilder.class).buildStormParam(); default: return null; } } catch (Exception e) { logger.error("Get BaseParam object error", e); return null; } } static BaseParam getBaseParam(String type, String parameter); }	@Test public void testGetBaseParam() { String parameter = "{\"type\":\"MYSQL_TO_HDFS\",\"reader\":{\"column\":[\"`id`\",\"`name`\",\"`email`\",\"`desc`\",\"`phone`\",\"`password`\",\"`role`\",\"`proxy_users`\",\"`create_time`\",\"`modify_time`\"],\"datasource\":\"test11111\",\"table\":[\"user\"]},\"writer\":{\"path\":\"/test/temp/here\",\"fileName\":\"filetest\",\"writeMode\":\"APPEND\",\"fileType\":\"ORC\",\"column\":[{\"name\":\"`id`\",\"type\":\"VARCHAR\"},{\"name\":\"`name`\",\"type\":\"VARCHAR\"},{\"name\":\"`email`\",\"type\":\"VARCHAR\"},{\"name\":\"`desc`\",\"type\":\"VARCHAR\"},{\"name\":\"`phone`\",\"type\":\"VARCHAR\"},{\"name\":\"`password`\",\"type\":\"VARCHAR\"},{\"name\":\"`role`\",\"type\":\"VARCHAR\"},{\"name\":\"`proxy_users`\",\"type\":\"VARCHAR\"},{\"name\":\"`create_time`\",\"type\":\"VARCHAR\"},{\"name\":\"`modify_time`\",\"type\":\"VARCHAR\"}]},\"setting\":{\"speed\":{\"channel\":1,\"byte\":104857600},\"errorLimit\":{\"record\":3,\"percentage\":0.05}}}"; String type = "IMPEXP"; ImpExpParam impExpParam = (ImpExpParam) BaseParamFactory.getBaseParam(type, parameter); assertTrue(impExpParam.checkValid()); }
MailSendUtil { public static boolean sendMails(Collection<String> receivers, String title, String content) { if (receivers == null) { LOGGER.error("Mail receivers is null."); return false; } receivers.removeIf((from) -> (StringUtils.isEmpty(from))); if (receivers.isEmpty()) { LOGGER.error("Mail receivers is empty."); return false; } HtmlEmail email = new HtmlEmail(); try { email.setHostName(mailServerHost); email.setSmtpPort(mailServerPort); email.setCharset("UTF-8"); for (String receiver : receivers) { email.addTo(receiver); } email.setFrom(mailSender, mailSender); email.setAuthentication(mailSender, mailPasswd); email.setSubject(title); email.setMsg(content); email.send(); return true; } catch (Throwable e) { LOGGER.error("Send email to {} failed", StringUtils.join(",", receivers), e); } return false; } static boolean sendMails(Collection<String> receivers, String title, String content); }	@Test public void testSendMails() { String[] mails = new String[]{"[email protected]"}; String title = "test from swordfish"; String content = "test"; MailSendUtil.sendMails(Arrays.asList(mails), title, content); }
CrontabUtil { public static ScheduleType getCycle(Cron cron) { return min(cron).next(hour(cron)).next(day(cron)).next(week(cron)).next(month(cron)).getCycle(); } static Cron parseCron(String crontab); static CronExpression parseCronExp(String crontab); static ScheduleType getCycle(Cron cron); static ScheduleType getCycle(String crontab); static List<Date> getCycleFireDate(Date startTime, Date endTime, CronExpression cronExpression); static ZonedDateTime parseDateToZdt(Date date); static Date parseZdtToDate(ZonedDateTime zdt); static Map.Entry<Date, Date> getPreCycleDate(Date scheduledFireTime, ScheduleType scheduleType); }	@Test public void testGetCycle() { String minCrontab = "0 0/2 0-23 * * ? "; String hourCrontab = "0 0 2-22/2 * ? "; String dayCrontab = "0 0 0 * ? "; String weekCrontab1 = "0 0 0 ? SUN,SAT "; String weekCrontab2 = "0 0 0 ? SUN "; String monthCrontab1 = "0 0 0 1 ? "; String monthCrontab2 = "0 0 0 1,3 ? *"; Cron minCron = parseCron(minCrontab); Cron hourCron = parseCron(hourCrontab); Cron dayCron = parseCron(dayCrontab); Cron weekCron1 = parseCron(weekCrontab1); Cron weekCron2 = parseCron(weekCrontab2); Cron monthCron1 = parseCron(monthCrontab1); Cron monthCron2 = parseCron(monthCrontab2); ScheduleType minType = getCycle(minCron); ScheduleType hourType = getCycle(hourCron); ScheduleType dayType = getCycle(dayCron); ScheduleType weekType1 = getCycle(weekCron1); ScheduleType weekType2 = getCycle(weekCron2); ScheduleType monthType1 = getCycle(monthCron1); ScheduleType monthType2 = getCycle(monthCron2); assertEquals(minType, ScheduleType.MINUTE); assertEquals(hourType, ScheduleType.HOUR); assertEquals(dayType, ScheduleType.DAY); assertEquals(weekType1, ScheduleType.WEEK); assertEquals(weekType2, ScheduleType.WEEK); assertEquals(monthType1, ScheduleType.MONTH); assertEquals(monthType2, ScheduleType.MONTH); }
CrontabUtil { public static List<Date> getCycleFireDate(Date startTime, Date endTime, CronExpression cronExpression) { List<Date> dateList = new ArrayList<>(); while (true) { startTime = cronExpression.getNextValidTimeAfter(startTime); if (startTime.after(endTime)) { break; } dateList.add(startTime); } return dateList; } static Cron parseCron(String crontab); static CronExpression parseCronExp(String crontab); static ScheduleType getCycle(Cron cron); static ScheduleType getCycle(String crontab); static List<Date> getCycleFireDate(Date startTime, Date endTime, CronExpression cronExpression); static ZonedDateTime parseDateToZdt(Date date); static Date parseZdtToDate(ZonedDateTime zdt); static Map.Entry<Date, Date> getPreCycleDate(Date scheduledFireTime, ScheduleType scheduleType); }	@Test public void testGetCycleFireDate() throws ParseException { String hourCrontab = "0 0 2-22/2 * * ? *"; CronExpression cronExpression = CrontabUtil.parseCronExp(hourCrontab); Date startTime = new Date(1495555200000L); Date endTime = new Date(1495814400000L); List<Date> dateList = CrontabUtil.getCycleFireDate(startTime, endTime, cronExpression); for (Date date : dateList) { System.out.println(date); } }
CrontabUtil { public static Map.Entry<Date, Date> getPreCycleDate(Date scheduledFireTime, ScheduleType scheduleType) { Calendar scheduleStartTime = Calendar.getInstance(); scheduleStartTime.setTime(scheduledFireTime); Calendar scheduleEndTime = Calendar.getInstance(); scheduleEndTime.setTime(scheduledFireTime); switch (scheduleType) { case MINUTE: scheduleStartTime.add(Calendar.MINUTE, -1); scheduleStartTime.set(Calendar.SECOND, 0); scheduleEndTime.set(Calendar.SECOND, 0); break; case HOUR: scheduleStartTime.add(Calendar.HOUR_OF_DAY, -1); scheduleStartTime.set(Calendar.MINUTE, 0); scheduleStartTime.set(Calendar.SECOND, 0); scheduleEndTime.set(Calendar.MINUTE, 0); scheduleEndTime.set(Calendar.SECOND, 0); break; case DAY: scheduleStartTime.add(Calendar.DAY_OF_MONTH, -1); scheduleStartTime.set(Calendar.HOUR_OF_DAY, 0); scheduleStartTime.set(Calendar.MINUTE, 0); scheduleStartTime.set(Calendar.SECOND, 0); scheduleEndTime.set(Calendar.HOUR_OF_DAY, 0); scheduleEndTime.set(Calendar.MINUTE, 0); scheduleEndTime.set(Calendar.SECOND, 0); break; case WEEK: scheduleStartTime.setFirstDayOfWeek(Calendar.MONDAY); scheduleEndTime.setFirstDayOfWeek(Calendar.MONDAY); scheduleStartTime.add(Calendar.WEEK_OF_YEAR, -1); scheduleStartTime.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); scheduleStartTime.set(Calendar.HOUR_OF_DAY, 0); scheduleStartTime.set(Calendar.MINUTE, 0); scheduleStartTime.set(Calendar.SECOND, 0); scheduleEndTime.setTime(scheduleStartTime.getTime()); scheduleEndTime.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); scheduleEndTime.set(Calendar.HOUR_OF_DAY, 0); scheduleEndTime.set(Calendar.MINUTE, 0); scheduleEndTime.set(Calendar.SECOND, 0); break; case MONTH: scheduleStartTime.add(Calendar.MONTH, -1); scheduleStartTime.set(Calendar.DAY_OF_MONTH, 1); scheduleStartTime.set(Calendar.HOUR_OF_DAY, 0); scheduleStartTime.set(Calendar.MINUTE, 0); scheduleStartTime.set(Calendar.SECOND, 0); scheduleEndTime.setTime(scheduleStartTime.getTime()); scheduleEndTime.set(Calendar.DAY_OF_MONTH, scheduleEndTime.getActualMaximum(Calendar.DAY_OF_MONTH)); scheduleEndTime.set(Calendar.HOUR_OF_DAY, 0); scheduleEndTime.set(Calendar.MINUTE, 0); scheduleEndTime.set(Calendar.SECOND, 0); break; default: } return new AbstractMap.SimpleImmutableEntry<>(scheduleStartTime.getTime(), scheduleEndTime.getTime()); } static Cron parseCron(String crontab); static CronExpression parseCronExp(String crontab); static ScheduleType getCycle(Cron cron); static ScheduleType getCycle(String crontab); static List<Date> getCycleFireDate(Date startTime, Date endTime, CronExpression cronExpression); static ZonedDateTime parseDateToZdt(Date date); static Date parseZdtToDate(ZonedDateTime zdt); static Map.Entry<Date, Date> getPreCycleDate(Date scheduledFireTime, ScheduleType scheduleType); }	@Test public void testGetPreCycleDate() { Date now = new Date(); System.out.println("now: " + now); Map.Entry<Date, Date> minMap = CrontabUtil.getPreCycleDate(now, ScheduleType.MINUTE); System.out.println("min level is " + minMap.getKey() + " - " + minMap.getValue()); Map.Entry<Date, Date> hourMap = CrontabUtil.getPreCycleDate(now, ScheduleType.HOUR); System.out.println("hour level is " + hourMap.getKey() + " - " + hourMap.getValue()); Map.Entry<Date, Date> dayMap = CrontabUtil.getPreCycleDate(now, ScheduleType.DAY); System.out.println("day level is " + dayMap.getKey() + " - " + dayMap.getValue()); Map.Entry<Date, Date> weekMap = CrontabUtil.getPreCycleDate(now, ScheduleType.WEEK); System.out.println("week level is " + weekMap.getKey() + " - " + weekMap.getValue()); Map.Entry<Date, Date> monthMap = CrontabUtil.getPreCycleDate(now, ScheduleType.MONTH); System.out.println("month level is " + monthMap.getKey() + " - " + monthMap.getValue()); }
FlowNode { public void setDep(String dep) throws IOException { this.dep = dep; this.depList = JsonUtil.parseObjectList(dep, String.class); } int getId(); void setId(int id); String getName(); void setName(String name); String getDesc(); void setDesc(String desc); String getType(); void setType(String type); int getFlowId(); void setFlowId(int flowId); String getParameter(); void setParameter(String parameter); String getDep(); void setDep(String dep); String getExtras(); void setExtras(String extras); List<String> getDepList(); void setDepList(List<String> depList); @Override boolean equals(Object o); @Override int hashCode(); }	@Test public void testSetDep() throws IOException { }
FlowNode { public void setName(String name) { this.name = name; } int getId(); void setId(int id); String getName(); void setName(String name); String getDesc(); void setDesc(String desc); String getType(); void setType(String type); int getFlowId(); void setFlowId(int flowId); String getParameter(); void setParameter(String parameter); String getDep(); void setDep(String dep); String getExtras(); void setExtras(String extras); List<String> getDepList(); void setDepList(List<String> depList); @Override boolean equals(Object o); @Override int hashCode(); }	@Test public void testDeserializer() { String nodeStr = "{\"name\":\"shelljob1\",\"desc\":\"shell\",\"type\":\"VIRTUAL\",\"parameter\":{\"script\":\"echo shelljob1\"},\"dep\":[],\"extras\":null}"; FlowNode flowNode = JsonUtil.parseObject(nodeStr, FlowNode.class); List<FlowNode> nodes = new ArrayList<>(); nodes.add(flowNode); flowNode.setName("shelljob2"); nodes.add(flowNode); String nodesStr = JsonUtil.toJsonString(nodes); }
ParamHelper { public static String resolvePlaceholders(String text, Map<String, String> paramMap) { if (StringUtils.isEmpty(text)) { return text; } String cycTimeStr = paramMap.get(SystemParamManager.CYC_TIME); Date cycTime = getCycTime(cycTimeStr); text = PlaceholderUtil.resolvePlaceholders(text, paramMap, true); if (cycTime != null) { text = TimePlaceholderUtil.resolvePlaceholders(text, cycTime, true); } return text; } static String resolvePlaceholders(String text, Map<String, String> paramMap); }	@Test public void testResolvePlaceholders() { Map<String, String> definedParamMap = SystemParamManager .buildSystemParam(ExecType.DIRECT, new Date(), 200, "job id 001"); String sqls = "${sf.system.bizdate}"; System.out.println(ParamHelper.resolvePlaceholders(sqls, definedParamMap)); sqls = "${sf.system.bizcurdate}"; System.out.println(ParamHelper.resolvePlaceholders(sqls, definedParamMap)); sqls = "${sf.system.cyctime}"; System.out.println(ParamHelper.resolvePlaceholders(sqls, definedParamMap)); sqls = "$[yyyyMMdd]"; System.out.println(ParamHelper.resolvePlaceholders(sqls, definedParamMap)); sqls = "${sf.system.execId}"; System.out.println(ParamHelper.resolvePlaceholders(sqls, definedParamMap)); sqls = "${sf.system.jobId}"; System.out.println(ParamHelper.resolvePlaceholders(sqls, definedParamMap)); }
DagHelper { public static FlowDag findNodeDepDag(FlowDag flowDag, FlowNode node, boolean isDependentBy) { FlowDag dagRequestDep = new FlowDag(); List<FlowNode> nodesDep = new ArrayList<>(); dagRequestDep.setNodes(nodesDep); List<FlowNodeRelation> edgesDep = new ArrayList<>(); dagRequestDep.setEdges(edgesDep); List<FlowNode> nodesTemp = new ArrayList<>(); List<FlowNode> nodesTempSwap = new ArrayList<>(); List<FlowNodeRelation> edges = flowDag.getEdges(); nodesTemp.add(node); while (!nodesTemp.isEmpty()) { Iterator<FlowNode> iterator = nodesTemp.iterator(); while (iterator.hasNext()) { FlowNode flowNode = iterator.next(); for (FlowNodeRelation edge : edges) { if (isDependentBy) { if (edge.getStartNode().equals(flowNode.getName())) { edgesDep.add(edge); FlowNode endFlowNode = findNodeByName(flowDag.getNodes(), edge.getEndNode()); if (endFlowNode != null) { if (!nodesDep.contains(endFlowNode)) { nodesTempSwap.add(endFlowNode); } } else { throw new DagException(String.format("DAG error ，end node %s not in flow dag", edge.getEndNode())); } } } else { if (edge.getEndNode().equals(flowNode.getName())) { edgesDep.add(edge); FlowNode startFlowNode = findNodeByName(flowDag.getNodes(), edge.getStartNode()); if (startFlowNode != null) { if (!nodesDep.contains(startFlowNode)) { nodesTempSwap.add(startFlowNode); } } else { throw new DagException(String.format("DAG error ，end node %s not in flow dag", edge.getStartNode())); } } } } nodesDep.add(flowNode); } nodesTemp.clear(); nodesTemp.addAll(nodesTempSwap); nodesTempSwap.clear(); } return dagRequestDep; } static FlowDag findNodeDepDag(FlowDag flowDag, FlowNode node, boolean isDependentBy); static FlowNode findNodeByName(List<FlowNode> nodeDetails, String nodeName); }	@Test public void testFindNodeDepDag() { FlowDag flowDag = new FlowDag(); List<FlowNodeRelation> relas = new ArrayList<>(); relas.add(new FlowNodeRelation("shell1", "shell2")); relas.add(new FlowNodeRelation("shell1", "shell3")); relas.add(new FlowNodeRelation("shell2", "shell4")); relas.add(new FlowNodeRelation("shell4", "shell5")); flowDag.setEdges(relas); List<FlowNode> nodes = new ArrayList<>(); nodes.add(JsonUtil.parseObject("{\"name\":\"shell1\"}", FlowNode.class)); nodes.add(JsonUtil.parseObject("{\"name\":\"shell2\"}", FlowNode.class)); nodes.add(JsonUtil.parseObject("{\"name\":\"shell3\"}", FlowNode.class)); nodes.add(JsonUtil.parseObject("{\"name\":\"shell4\"}", FlowNode.class)); nodes.add(JsonUtil.parseObject("{\"name\":\"shell5\"}", FlowNode.class)); flowDag.setNodes(nodes); FlowNode node = JsonUtil.parseObject("{\"name\":\"shell2\"}", FlowNode.class); FlowDag flowDag1 = DagHelper.findNodeDepDag(flowDag, node, true); assertEquals(3, flowDag1.getNodes().size()); assertEquals("shell2:shell4,shell4:shell5", flowDag1.getEdges().stream().map(rela -> rela.getStartNode() + ":" + rela.getEndNode()).collect(Collectors.joining(","))); FlowDag flowDagPre = DagHelper.findNodeDepDag(flowDag, node, false); assertEquals("shell1,shell2", flowDagPre.getNodes().stream().map(n -> n.getName()).sorted().collect(Collectors.joining(","))); assertEquals("shell1:shell2", flowDagPre.getEdges().stream().map(rela -> rela.getStartNode() + ":" + rela.getEndNode()).collect(Collectors.joining(","))); }
AdHocDao extends BaseDao { public AdHoc getAdHoc(int id) { return adHocMapper.selectById(id); } boolean updateAdHoc(AdHoc adHoc); boolean updateAdHocStatus(AdHoc adHoc); AdHoc getAdHoc(int id); boolean updateAdHocResult(AdHocResult adHocResult); @Transactional(value = "TransactionManager") void initAdHocResult(int execId, List<String> execSqls); }	@Test public void testgetAdHoc() { }
FlowDao extends BaseDao { public ExecutionFlow queryExecutionFlow(int execId) { return executionFlowMapper.selectByExecId(execId); } ExecutionFlow queryExecutionFlow(int execId); int deleteExecutionNodes(int execId); List<ExecutionFlow> queryAllNoFinishFlow(); List<ExecutionFlow> queryNoFinishFlow(String worker); ExecutionFlow queryExecutionFlowByScheduleTime(int flowId, Date scheduleTime); boolean updateExecutionFlowStatus(int execId, FlowStatus status); boolean updateExecutionFlowStatus(int execId, FlowStatus status, String worker); boolean updateExecutionFlow(ExecutionFlow executionFlow); boolean updateExecutionFlowDataSub(ExecutionFlow executionFlow); ExecutionFlow scheduleFlowToExecution(Integer projectId, Integer workflowId, int submitUser, Date scheduleTime, ExecType runType, FailurePolicyType failurePolicyType, Integer maxTryTimes, String nodeName, NodeDepType nodeDep, NotifyType notifyType, List<String> mails, int timeout); @Transactional(value = "TransactionManager") void deleteWorkflow(int workflowId); void insertExecutionNode(ExecutionNode executionNode); void updateExecutionNode(ExecutionNode executionNode); ExecutionNode queryExecutionNode(long execId, String nodeName); Schedule querySchedule(int flowId); ProjectFlow projectFlowfindByName(int projectId, String name); ProjectFlow projectFlowFindById(int id); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void createProjectFlow(ProjectFlow projectFlow); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void modifyProjectFlow(ProjectFlow projectFlow); ProjectFlow projectFlowFindByPorjectNameAndName(String projectName, String name); List<ProjectFlow> projectFlowFindByProject(int projectId); ExecutionFlow executionFlowPreDate(int flowId, Date date); ExecutionFlow executionFlowPreDate2(int flowId, Date date); ExecutionFlow executionFlowByStartTimeAndScheduleTime(int flowId, Date startTIme, Date scheduleTime); }	@Test public void testQueryExecutionFlow() { }
FlowDao extends BaseDao { public ExecutionFlow scheduleFlowToExecution(Integer projectId, Integer workflowId, int submitUser, Date scheduleTime, ExecType runType, FailurePolicyType failurePolicyType, Integer maxTryTimes, String nodeName, NodeDepType nodeDep, NotifyType notifyType, List<String> mails, int timeout) throws Exception { logger.info("project id:{}, workflow id:{}, schedule time:{}", projectId, workflowId, scheduleTime); List<FlowNode> flowNodes = flowNodeMapper.selectByFlowId(workflowId); List<FlowNodeRelation> flowNodeRelations = new ArrayList<>(); for (FlowNode flowNode : flowNodes) { String dep = flowNode.getDep(); List<String> depList = JsonUtil.parseObjectList(dep, String.class); if (depList != null) { for (String depNode : depList) { flowNodeRelations.add(new FlowNodeRelation(depNode, flowNode.getName())); } } } ProjectFlow projectFlow = projectFlowMapper.findById(workflowId); FlowDag flowDag = new FlowDag(); flowDag.setEdges(flowNodeRelations); flowDag.setNodes(flowNodes); ExecutionFlow executionFlow = new ExecutionFlow(); Date now = new Date(); executionFlow.setFlowId(workflowId); executionFlow.setSubmitUserId(submitUser); executionFlow.setSubmitTime(now); executionFlow.setQueue(projectFlow.getQueue()); executionFlow.setProxyUser(projectFlow.getProxyUser()); executionFlow.setScheduleTime(scheduleTime); executionFlow.setStartTime(now); if (nodeName != null) { FlowNode flowNode = DagHelper.findNodeByName(flowNodes, nodeName); if (flowNode != null) { switch (nodeDep) { case NODE_POST: flowDag = DagHelper.findNodeDepDag(flowDag, flowNode, true); break; case NODE_PRE: flowDag = DagHelper.findNodeDepDag(flowDag, flowNode, false); break; case NODE_ONLY: default: flowDag.setEdges(null); flowDag.setNodes(Arrays.asList(flowNode)); } } else { throw new Exception(String.format("node %s not found in flow %d", nodeName, workflowId)); } } executionFlow.setWorkflowData(JsonUtil.toJsonString(flowDag)); executionFlow.setUserDefinedParams(projectFlow.getUserDefinedParams()); executionFlow.setType(runType); executionFlow.setFailurePolicy(failurePolicyType); executionFlow.setMaxTryTimes(maxTryTimes); executionFlow.setNotifyType(notifyType); executionFlow.setNotifyMailList(mails); executionFlow.setTimeout(timeout); executionFlow.setStatus(FlowStatus.INIT); executionFlow.setExtras(projectFlow.getExtras()); executionFlowMapper.insertAndGetId(executionFlow); return executionFlow; } ExecutionFlow queryExecutionFlow(int execId); int deleteExecutionNodes(int execId); List<ExecutionFlow> queryAllNoFinishFlow(); List<ExecutionFlow> queryNoFinishFlow(String worker); ExecutionFlow queryExecutionFlowByScheduleTime(int flowId, Date scheduleTime); boolean updateExecutionFlowStatus(int execId, FlowStatus status); boolean updateExecutionFlowStatus(int execId, FlowStatus status, String worker); boolean updateExecutionFlow(ExecutionFlow executionFlow); boolean updateExecutionFlowDataSub(ExecutionFlow executionFlow); ExecutionFlow scheduleFlowToExecution(Integer projectId, Integer workflowId, int submitUser, Date scheduleTime, ExecType runType, FailurePolicyType failurePolicyType, Integer maxTryTimes, String nodeName, NodeDepType nodeDep, NotifyType notifyType, List<String> mails, int timeout); @Transactional(value = "TransactionManager") void deleteWorkflow(int workflowId); void insertExecutionNode(ExecutionNode executionNode); void updateExecutionNode(ExecutionNode executionNode); ExecutionNode queryExecutionNode(long execId, String nodeName); Schedule querySchedule(int flowId); ProjectFlow projectFlowfindByName(int projectId, String name); ProjectFlow projectFlowFindById(int id); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void createProjectFlow(ProjectFlow projectFlow); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void modifyProjectFlow(ProjectFlow projectFlow); ProjectFlow projectFlowFindByPorjectNameAndName(String projectName, String name); List<ProjectFlow> projectFlowFindByProject(int projectId); ExecutionFlow executionFlowPreDate(int flowId, Date date); ExecutionFlow executionFlowPreDate2(int flowId, Date date); ExecutionFlow executionFlowByStartTimeAndScheduleTime(int flowId, Date startTIme, Date scheduleTime); }	@Test public void testScheduleFlowToExecution() { }
FlowDao extends BaseDao { public Schedule querySchedule(int flowId) { return scheduleMapper.selectByFlowId(flowId); } ExecutionFlow queryExecutionFlow(int execId); int deleteExecutionNodes(int execId); List<ExecutionFlow> queryAllNoFinishFlow(); List<ExecutionFlow> queryNoFinishFlow(String worker); ExecutionFlow queryExecutionFlowByScheduleTime(int flowId, Date scheduleTime); boolean updateExecutionFlowStatus(int execId, FlowStatus status); boolean updateExecutionFlowStatus(int execId, FlowStatus status, String worker); boolean updateExecutionFlow(ExecutionFlow executionFlow); boolean updateExecutionFlowDataSub(ExecutionFlow executionFlow); ExecutionFlow scheduleFlowToExecution(Integer projectId, Integer workflowId, int submitUser, Date scheduleTime, ExecType runType, FailurePolicyType failurePolicyType, Integer maxTryTimes, String nodeName, NodeDepType nodeDep, NotifyType notifyType, List<String> mails, int timeout); @Transactional(value = "TransactionManager") void deleteWorkflow(int workflowId); void insertExecutionNode(ExecutionNode executionNode); void updateExecutionNode(ExecutionNode executionNode); ExecutionNode queryExecutionNode(long execId, String nodeName); Schedule querySchedule(int flowId); ProjectFlow projectFlowfindByName(int projectId, String name); ProjectFlow projectFlowFindById(int id); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void createProjectFlow(ProjectFlow projectFlow); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void modifyProjectFlow(ProjectFlow projectFlow); ProjectFlow projectFlowFindByPorjectNameAndName(String projectName, String name); List<ProjectFlow> projectFlowFindByProject(int projectId); ExecutionFlow executionFlowPreDate(int flowId, Date date); ExecutionFlow executionFlowPreDate2(int flowId, Date date); ExecutionFlow executionFlowByStartTimeAndScheduleTime(int flowId, Date startTIme, Date scheduleTime); }	@Test public void testQuerySchedule() { }
FlowDao extends BaseDao { public ProjectFlow projectFlowfindByName(int projectId, String name) { ProjectFlow projectFlow = projectFlowMapper.findByName(projectId, name); if (projectFlow != null) { List<FlowNode> flowNodeList = flowNodeMapper.selectByFlowId(projectFlow.getId()); projectFlow.setFlowsNodes(flowNodeList); } return projectFlow; } ExecutionFlow queryExecutionFlow(int execId); int deleteExecutionNodes(int execId); List<ExecutionFlow> queryAllNoFinishFlow(); List<ExecutionFlow> queryNoFinishFlow(String worker); ExecutionFlow queryExecutionFlowByScheduleTime(int flowId, Date scheduleTime); boolean updateExecutionFlowStatus(int execId, FlowStatus status); boolean updateExecutionFlowStatus(int execId, FlowStatus status, String worker); boolean updateExecutionFlow(ExecutionFlow executionFlow); boolean updateExecutionFlowDataSub(ExecutionFlow executionFlow); ExecutionFlow scheduleFlowToExecution(Integer projectId, Integer workflowId, int submitUser, Date scheduleTime, ExecType runType, FailurePolicyType failurePolicyType, Integer maxTryTimes, String nodeName, NodeDepType nodeDep, NotifyType notifyType, List<String> mails, int timeout); @Transactional(value = "TransactionManager") void deleteWorkflow(int workflowId); void insertExecutionNode(ExecutionNode executionNode); void updateExecutionNode(ExecutionNode executionNode); ExecutionNode queryExecutionNode(long execId, String nodeName); Schedule querySchedule(int flowId); ProjectFlow projectFlowfindByName(int projectId, String name); ProjectFlow projectFlowFindById(int id); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void createProjectFlow(ProjectFlow projectFlow); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void modifyProjectFlow(ProjectFlow projectFlow); ProjectFlow projectFlowFindByPorjectNameAndName(String projectName, String name); List<ProjectFlow> projectFlowFindByProject(int projectId); ExecutionFlow executionFlowPreDate(int flowId, Date date); ExecutionFlow executionFlowPreDate2(int flowId, Date date); ExecutionFlow executionFlowByStartTimeAndScheduleTime(int flowId, Date startTIme, Date scheduleTime); }	@Test public void testProjectFlowfindByName() { }
FlowDao extends BaseDao { public ProjectFlow projectFlowFindById(int id) { ProjectFlow projectFlow = projectFlowMapper.findById(id); if (projectFlow != null) { List<FlowNode> flowNodeList = flowNodeMapper.selectByFlowId(projectFlow.getId()); projectFlow.setFlowsNodes(flowNodeList); } return projectFlow; } ExecutionFlow queryExecutionFlow(int execId); int deleteExecutionNodes(int execId); List<ExecutionFlow> queryAllNoFinishFlow(); List<ExecutionFlow> queryNoFinishFlow(String worker); ExecutionFlow queryExecutionFlowByScheduleTime(int flowId, Date scheduleTime); boolean updateExecutionFlowStatus(int execId, FlowStatus status); boolean updateExecutionFlowStatus(int execId, FlowStatus status, String worker); boolean updateExecutionFlow(ExecutionFlow executionFlow); boolean updateExecutionFlowDataSub(ExecutionFlow executionFlow); ExecutionFlow scheduleFlowToExecution(Integer projectId, Integer workflowId, int submitUser, Date scheduleTime, ExecType runType, FailurePolicyType failurePolicyType, Integer maxTryTimes, String nodeName, NodeDepType nodeDep, NotifyType notifyType, List<String> mails, int timeout); @Transactional(value = "TransactionManager") void deleteWorkflow(int workflowId); void insertExecutionNode(ExecutionNode executionNode); void updateExecutionNode(ExecutionNode executionNode); ExecutionNode queryExecutionNode(long execId, String nodeName); Schedule querySchedule(int flowId); ProjectFlow projectFlowfindByName(int projectId, String name); ProjectFlow projectFlowFindById(int id); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void createProjectFlow(ProjectFlow projectFlow); @Transactional(value = "TransactionManager", rollbackFor = Exception.class) void modifyProjectFlow(ProjectFlow projectFlow); ProjectFlow projectFlowFindByPorjectNameAndName(String projectName, String name); List<ProjectFlow> projectFlowFindByProject(int projectId); ExecutionFlow executionFlowPreDate(int flowId, Date date); ExecutionFlow executionFlowPreDate2(int flowId, Date date); ExecutionFlow executionFlowByStartTimeAndScheduleTime(int flowId, Date startTIme, Date scheduleTime); }	@Test public void testProjectFlowfindById() { }
VerifyUtil { public static boolean matcheUserName(String str) { return regexMatches(str, Constants.REGEX_USER_NAME); } static boolean regexMatches(String str, Pattern pattern); static boolean matcheProjectName(String str); static boolean matcheUserName(String str); static boolean matchEmail(String str); static boolean matcheResName(String str); static boolean matcheDatasourceName(String str); static boolean matchWorkflowName(String str); static boolean matchProxyUser(String str); }	@Test public void testMatcheUserName() { { String test = "bfd_test"; assertTrue(VerifyUtil.matcheUserName(test)); } }
VerifyUtil { public static boolean matcheProjectName(String str) { return regexMatches(str, Constants.REGEX_PROJECT_NAME); } static boolean regexMatches(String str, Pattern pattern); static boolean matcheProjectName(String str); static boolean matcheUserName(String str); static boolean matchEmail(String str); static boolean matcheResName(String str); static boolean matcheDatasourceName(String str); static boolean matchWorkflowName(String str); static boolean matchProxyUser(String str); }	@Test public void testMatcheProjectName() { { String test = "bfd_test"; assertTrue(VerifyUtil.matcheProjectName(test)); } }
VerifyUtil { public static boolean matcheResName(String str) { return regexMatches(str, Constants.REGEX_RES_NAME); } static boolean regexMatches(String str, Pattern pattern); static boolean matcheProjectName(String str); static boolean matcheUserName(String str); static boolean matchEmail(String str); static boolean matcheResName(String str); static boolean matcheDatasourceName(String str); static boolean matchWorkflowName(String str); static boolean matchProxyUser(String str); }	@Test public void testMatcheResName() { { assertTrue(VerifyUtil.matcheResName("aa.jar")); assertTrue(VerifyUtil.matcheResName("spark-examples-1.0-SNAPSHOT-hadoop2.6.0.jar")); } }
Graph { public synchronized void addVertex(VK key, VD vertex) { vertices.put(key, vertex); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testAddVertex() { clearAndTest(); graph.addVertex(1, "abc"); graph.addVertex(2, null); graph.addVertex(3, "def"); assertEquals(graph.getVertexNumber(), 3); assertEquals(graph.getVertex(1), "abc"); assertTrue(graph.containsVertex(1)); assertTrue(graph.getVertices().containsKey(1)); assertEquals(graph.getVertex(2), null); assertTrue(graph.containsVertex(2)); assertTrue(graph.getVertices().containsKey(2)); assertEquals(graph.getVertex(3), "def"); assertTrue(graph.containsVertex(3)); assertTrue(graph.getVertices().containsKey(3)); assertEquals(graph.getVertex(4), null); assertFalse(graph.containsVertex(4)); assertFalse(graph.getVertices().containsKey(4)); graph.addVertex(1, "def"); graph.addVertex(102, "css"); assertEquals(graph.getVertexNumber(), 4); assertEquals(graph.getVertex(1), "def"); assertEquals(graph.getVertex(102), "css"); assertTrue(graph.containsVertex(102)); assertTrue(graph.getVertices().containsKey(102)); }
Graph { public boolean addEdge(VK start, VK end) { return addEdge(start, end, false); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testAddEdge() { clearAndTest(); assertFalse(graph.addEdge(1, 2, "attr1")); graph.addVertex(1, "v1"); assertFalse(graph.addEdge(1, 2, "attr1")); graph.addVertex(2, "v2"); assertFalse(graph.addEdge(1, 1, "wrong")); assertTrue(graph.addEdge(1, 2, "attr_12")); assertFalse(graph.containsEdge(1, 3)); assertTrue(graph.containsEdge(1, 2)); assertEquals(graph.getEdgeNumber(), 1); assertEquals(graph.getEdge(1, 2), "attr_12"); assertEquals(graph.getEdges().size(), 1); assertTrue(graph.getEdges().containsKey(1)); graph.addVertex(3, "v3"); graph.addVertex(4, "v4"); assertTrue(graph.addEdge(3, 4, "attr_34")); assertTrue(graph.addEdge(1, 4, "attr_14")); assertTrue(graph.containsEdge(3, 4)); assertTrue(graph.containsEdge(1, 4)); assertEquals(graph.getEdgeNumber(), 3); assertEquals(graph.getEdge(3, 4), "attr_34"); assertEquals(graph.getEdge(1, 4), "attr_14"); assertEquals(graph.getEdges().size(), 2); assertTrue(graph.getEdges().containsKey(1)); assertTrue(graph.getEdges().containsKey(3)); assertEquals(graph.getEdges().get(1).size(), 2); assertEquals(graph.getEdges().get(3).size(), 1); clearAndTest(); assertTrue(graph.addEdge(1, 2, "attr1", true)); assertTrue(graph.addEdge(1, 3, "attr2", true)); assertFalse(graph.addEdge(1, 4, "attr2", false)); assertEquals(graph.getVertexNumber(), 3); assertEquals(graph.getEdgeNumber(), 2); assertTrue(graph.containsEdge(1, 2)); assertTrue(graph.containsEdge(1, 3)); assertTrue(graph.containsVertex(1)); assertTrue(graph.containsVertex(2)); assertTrue(graph.containsVertex(3)); }
Graph { public synchronized void removeVertex(VK key) { List<Map.Entry<VK, VK>> pairs = new ArrayList<>(); for (VK postKey : getPostNode(key)) { pairs.add(new AbstractMap.SimpleEntry<>(key, postKey)); } for (VK preKey : getPreNode(key)) { pairs.add(new AbstractMap.SimpleEntry<>(preKey, key)); } for (Map.Entry<VK, VK> pair : pairs) { removeEdge(pair.getKey(), pair.getValue()); } vertices.remove(key); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testRemoveVertex() { construtGraph(); graph.removeVertex(4); assertEquals(graph.getVertexNumber(), 9); assertEquals(graph.getEdgeNumber(), 6); graph.removeVertex(6); assertEquals(graph.getVertexNumber(), 8); assertEquals(graph.getEdgeNumber(), 5); graph.removeVertex(8); assertEquals(graph.getVertexNumber(), 7); assertEquals(graph.getEdgeNumber(), 5); graph.removeVertex(9); assertEquals(graph.getVertexNumber(), 6); assertEquals(graph.getEdgeNumber(), 5); graph.removeVertex(1); assertEquals(graph.getVertexNumber(), 5); assertEquals(graph.getEdgeNumber(), 3); graph.removeVertex(3); assertEquals(graph.getVertexNumber(), 4); assertEquals(graph.getEdgeNumber(), 2); graph.removeVertex(2); assertEquals(graph.getVertexNumber(), 3); assertEquals(graph.getEdgeNumber(), 1); graph.removeVertex(7); assertEquals(graph.getVertexNumber(), 2); assertEquals(graph.getEdgeNumber(), 0); graph.removeVertex(5); assertEquals(graph.getVertexNumber(), 1); assertEquals(graph.getEdgeNumber(), 0); graph.removeVertex(10); assertEquals(graph.getVertexNumber(), 0); assertEquals(graph.getEdgeNumber(), 0); }
Graph { public synchronized void removeEdge(VK start, VK end) { removeEdge(start, end, edges); removeEdge(end, start, reverseEdges); } Graph(); synchronized void addVertex(VK key, VD vertex); synchronized void addVertexIfAbsent(VK key, VD vertex); synchronized void removeVertex(VK key); boolean addEdge(VK start, VK end); boolean addEdge(VK start, VK end, boolean createVertex); boolean addEdge(VK start, VK end, ED edge); synchronized boolean addEdge(VK start, VK end, ED edge, boolean createVertex); synchronized void removeEdge(VK start, VK end); boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey); synchronized boolean forceRefreshPreEdges(Collection<VK> addStartKeys, VK endKey, boolean createVertex); boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey); synchronized boolean addRemoveMultiEdges(Collection<VK> removeStartKeys, Collection<VK> addStartKeys, VK endKey, boolean createVertex); synchronized void clear(); synchronized boolean containsVertex(VK key); synchronized VD getVertex(VK key); Map<VK, VD> getVertices(); synchronized boolean containsEdge(VK startKey, VK endKey); Map<VK, Map<VK, ED>> getEdges(); synchronized ED getEdge(VK startKey, VK endKey); synchronized int getEdgeNumber(); int getVertexNumber(); synchronized Collection<VK> getStartVertex(); synchronized Collection<VK> getEndVertex(); Set<VK> getPreNode(VK key); Map<VK, ED> getPreNodeAttr(VK key); Set<VK> getPostNode(VK key); Map<VK, ED> getPostNodeAttr(VK key); synchronized int getIndegree(VK key); synchronized int getOutdegree(VK key); boolean hasCycle(); List<VK> broadFirstSearch(); List<VK> depthFirstSearch(); List<VK> topologicalSort(); synchronized boolean isConnected(); }	@Test public void testRemoveEdge() { construtGraph(); graph.removeEdge(1, 2); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 8); assertEquals(graph.getEdges().size(), 7); graph.removeEdge(1, 5); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 8); assertEquals(graph.getEdges().size(), 7); graph.removeEdge(1, 3); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 7); assertEquals(graph.getEdges().size(), 7); graph.removeEdge(1, 4); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 6); assertEquals(graph.getEdges().size(), 6); graph.removeEdge(2, 5); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 5); assertEquals(graph.getEdges().size(), 5); graph.removeEdge(3, 5); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 4); assertEquals(graph.getEdges().size(), 4); graph.removeEdge(5, 7); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 3); assertEquals(graph.getEdges().size(), 3); graph.removeEdge(10, 4); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 2); assertEquals(graph.getEdges().size(), 2); graph.removeEdge(4, 6); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 1); assertEquals(graph.getEdges().size(), 1); graph.removeEdge(6, 7); assertEquals(graph.getVertexNumber(), 10); assertEquals(graph.getEdgeNumber(), 0); assertTrue(graph.getEdges().isEmpty()); }
DroneInstance extends Instance { public static String getTeamname(Discoverer discoverer, String id){ return discoverer.getNode(new DroneInstance(id)).getValues().getOrDefault("team", null); } DroneInstance(String id); DroneInstance(String id, Map<String, String> properties); static String getTeamname(Discoverer discoverer, String id); }	@Test public void getTeamname() throws Exception { String id = ""; Map<String, String> props = new HashMap<>(); DroneInstance instance = new DroneInstance(id); MockDiscoverer discoverer = spy(new MockDiscoverer()); MockDiscoveryStoredNode node = new MockDiscoveryStoredNode(id, props); doReturn(node).when(discoverer).getNode(any()); Assert.assertEquals(DroneInstance.getTeamname(discoverer, id), null); String teamname = "test_team"; props.put("team", teamname); Assert.assertEquals(DroneInstance.getTeamname(discoverer, id), teamname); }
Gun { public void fireBullet(D3PolarCoordinate direction) { long currentTimeMs = System.currentTimeMillis(); if (currentTimeMs >= nextShotAtMs && direction.getLength() <= MAX_DISTANCE) { FireBulletMessage msg = new FireBulletMessage(); msg.setDamage(20); msg.setFiredById(drone.getIdentifier()); msg.setIdentifier(UUID.randomUUID().toString()); msg.setType(EntityType.BULLET); msg.setDirection(direction); msg.setVelocity(direction.toVector().scale(BULLET_SPEED / direction.toVector().length())); msg.setPosition(gps.getPosition()); msg.setAcceleration(new D3Vector()); publisher.send(msg); lastShotAtMs = currentTimeMs; nextShotAtMs = lastShotAtMs + BASE_SHOT_TIME_BETWEEN + new Random().nextInt(MAX_OFFSET_SHOT_TIME); callbacks.forEach(callback -> callback.run(msg)); log.info("Firing bullet in direction " + direction + "! Next shot possible in " + ((double) (nextShotAtMs - currentTimeMs) / 1000) + " seconds."); } } Gun(); Gun(Publisher publisher, DroneInit drone, GPS gps, long lastShotAtMs, long nextShotAtMs); double getMaxDistance(); long msSinceLastShot(); void fireBullet(D3PolarCoordinate direction); final void registerCallback(GunCallback callback); }	@Test public void fireBullet() throws Exception { D3PolarCoordinate direction = new D3PolarCoordinate(90, 90, 100); gun.fireBullet(direction); Assert.assertThat(publisher.getReceivedMessages().size(), is(1)); FireBulletMessage receivedMessage = (FireBulletMessage) publisher.getReceivedMessages().get(0); Assert.assertThat(receivedMessage.getDamage(), is(20)); Assert.assertThat(receivedMessage.getFiredById(), is(drone.getIdentifier())); Assert.assertThat(receivedMessage.getType(), is(BULLET)); Assert.assertThat(receivedMessage.getDirection(), is(Optional.of(direction))); Assert.assertThat(receivedMessage.getVelocity().get().length(), is(BULLET_SPEED)); Assert.assertThat(receivedMessage.getPosition(), is(Optional.of(gps.getPosition()))); int sizeReceivedMessages = publisher.getReceivedMessages().size(); gun.fireBullet(direction); Assert.assertEquals(sizeReceivedMessages, publisher.getReceivedMessages().size()); setField(gun, "lastShotAtMs", System.currentTimeMillis() - 1000); setField(gun, "nextShotAtMs", System.currentTimeMillis()); direction = new D3PolarCoordinate(90, 90, MAX_DISTANCE + 10); gun.fireBullet(direction); Assert.assertEquals(sizeReceivedMessages, publisher.getReceivedMessages().size()); }
Tactic extends ManagedThread implements Subscriber { @Override protected final void work() throws InterruptedException { if (ticker.timeIsExceeded()) { ticker.reset(); Thread t = new Thread(this::calculateTactics); t.start(); workTimoutTimer.reset(); while (t.isAlive()) { if (workTimoutTimer.timeIsExceeded()) { t.interrupt(); } } } } Radar getRadar(); GPS getGps(); Engine getEngine(); Gun getGun(); Radio getRadio(); final void startTactic(); final void stopTactic(); @Override @Deprecated final void destroy(); @Override void receive(Object msg, MultipartCallbacks multipartCallbacks); final String getIdentifier(); final Set<String> getAvailableComponents(); }	@Test public void testWork() throws Exception { TimeoutTimer ticker = getField(tactic, "ticker"); double timeout = getField(ticker, "timeout"); verify(tacticMock, times(0)).calculateTactics(); ticker.reset(); tactic.work(); verify(tacticMock, times(0)).calculateTactics(); TestUtils.setField(ticker, "lastTime", System.currentTimeMillis() - (long) timeout - 1L); tactic.work(); verify(tacticMock, times(1)).calculateTactics(); } @Test public void testWorkWithSlowTactic() throws Exception { double timeout = getField(getField(tactic, "ticker"), "timeout"); long durationLongCommand = (long) timeout * 5; boolean[] isInterrupted = new boolean[1]; Tactic tacticSlow = new DoNothingTactic() { @Override protected void calculateTactics() { try { Thread.sleep(durationLongCommand); } catch (InterruptedException e) { isInterrupted[0] = true; } } }; long executeStart = System.currentTimeMillis(); tacticSlow.work(); long executeEnd = System.currentTimeMillis(); Assert.assertTrue(isInterrupted[0]); Assert.assertTrue(executeEnd - executeStart < durationLongCommand); }
Tactic extends ManagedThread implements Subscriber { public final Set<String> getAvailableComponents() { Set<String> componentlist = new HashSet<>(); if (radar != null) { componentlist.add("radar"); } if (gps != null) { componentlist.add("gps"); } if (engine != null) { componentlist.add("engine"); } if (radio != null) { componentlist.add("radio"); } if (gun != null) { componentlist.add("gun"); } return componentlist; } Radar getRadar(); GPS getGps(); Engine getEngine(); Gun getGun(); Radio getRadio(); final void startTactic(); final void stopTactic(); @Override @Deprecated final void destroy(); @Override void receive(Object msg, MultipartCallbacks multipartCallbacks); final String getIdentifier(); final Set<String> getAvailableComponents(); }	@Test public void getAvailableComponents() throws Exception { Assert.assertEquals(new HashSet<>(Arrays.asList("engine", "radio", "radar", "gps", "gun")), tactic.getAvailableComponents()); setField(tactic, "gun", null); Assert.assertEquals(new HashSet<>(Arrays.asList("engine", "radio", "radar", "gps")), tactic.getAvailableComponents()); }
DroneInit { public void start() throws IOException { log.info("Starting the drone now!"); this.registerDroneService(); } DroneInit(String identifier, Discoverer discoverer, Instance registeredInstance); DroneInit(); String getIdentifier(); void setIdentifier(String identifier); static Logger getLog(); Discoverer getDiscoverer(); void setDiscoverer(Discoverer discoverer); Instance getRegisteredInstance(); void setRegisteredInstance(Instance registeredInstance); void start(); void stop(); String getTeamname(); void initIdentifier(); }	@Test public void testStart() throws Exception { environmentVariables.set("DRONENAME", instance.getName()); drone.initIdentifier(); drone.start(); Assert.assertTrue(mockDiscoverer.getRegisteredInstances().parallelStream().filter(ri -> ri.getName().equals(instance.getName())).count() == 1); drone.start(); Assert.assertThat(drone.getIdentifier(), startsWith(instance.getName() + "-")); Assert.assertThat(mockDiscoverer.getRegisteredInstances().size(), is(2)); }
DroneInit { public void stop() throws IOException { log.info("Stopping the drone now!"); this.unregisterDroneService(); } DroneInit(String identifier, Discoverer discoverer, Instance registeredInstance); DroneInit(); String getIdentifier(); void setIdentifier(String identifier); static Logger getLog(); Discoverer getDiscoverer(); void setDiscoverer(Discoverer discoverer); Instance getRegisteredInstance(); void setRegisteredInstance(Instance registeredInstance); void start(); void stop(); String getTeamname(); void initIdentifier(); }	@Test public void testStop() throws Exception { testStart(); drone.stop(); Assert.assertTrue(mockDiscoverer.getRegisteredInstances().parallelStream().filter(ri -> ri.getName().equals(instance.getName())).count() == 1); Assert.assertTrue(mockDiscoverer.getRegisteredInstances().get(0).getName().equals(instance.getName())); }
DroneInit { public String getTeamname() { String teamname = "unknown_team"; if (System.getenv("DRONE_TEAM") != null) { teamname = System.getenv("DRONE_TEAM"); } return teamname; } DroneInit(String identifier, Discoverer discoverer, Instance registeredInstance); DroneInit(); String getIdentifier(); void setIdentifier(String identifier); static Logger getLog(); Discoverer getDiscoverer(); void setDiscoverer(Discoverer discoverer); Instance getRegisteredInstance(); void setRegisteredInstance(Instance registeredInstance); void start(); void stop(); String getTeamname(); void initIdentifier(); }	@Test public void testGetTeamname() throws Exception { Assert.assertEquals("unknown_team", drone.getTeamname()); environmentVariables.set("DRONE_TEAM", "known_team"); Assert.assertEquals("known_team", drone.getTeamname()); }
DroneInit { public void initIdentifier() { Map<String, String> env = System.getenv(); if (env.containsKey("DRONENAME")) this.setIdentifier(env.get("DRONENAME")); else if (env.containsKey("COMPUTERNAME")) this.setIdentifier(env.get("COMPUTERNAME")); else if (env.containsKey("HOSTNAME")) this.setIdentifier(env.get("HOSTNAME")); else this.setIdentifier(UUID.randomUUID().toString()); } DroneInit(String identifier, Discoverer discoverer, Instance registeredInstance); DroneInit(); String getIdentifier(); void setIdentifier(String identifier); static Logger getLog(); Discoverer getDiscoverer(); void setDiscoverer(Discoverer discoverer); Instance getRegisteredInstance(); void setRegisteredInstance(Instance registeredInstance); void start(); void stop(); String getTeamname(); void initIdentifier(); }	@Test public void testInitIdentifier() throws Exception { DroneInit simpleDrone = new DroneInit(); Assert.assertThat(simpleDrone.getIdentifier(), isUUID()); environmentVariables.set("HOSTNAME", "HOSTNAME"); simpleDrone = new DroneInit(); Assert.assertThat(simpleDrone.getIdentifier(), is("HOSTNAME")); environmentVariables.set("COMPUTERNAME", "COMPUTERNAME"); simpleDrone = new DroneInit(); Assert.assertThat(simpleDrone.getIdentifier(), is("COMPUTERNAME")); environmentVariables.set("DRONENAME", "DRONENAME"); simpleDrone = new DroneInit(); Assert.assertThat(simpleDrone.getIdentifier(), is("DRONENAME")); }
Explosion extends UIUpdate { @Override public void execute(Pane pane) { ImageView explosionImage = new ImageView(new Image(getClass().getResourceAsStream("/explosion.png"))); explosionImage.setScaleX(scale); explosionImage.setScaleY(scale); explosionImage.setX(imageView.getLayoutX() - imageView.getFitWidth() / 2); explosionImage.setY(imageView.getLayoutY() - imageView.getFitHeight() / 2); SpriteAnimation explosionAnimation = new SpriteAnimation(explosionImage, Duration.millis(1000), 40, 8, 0, 0, 256, 256); explosionAnimation.setCycleCount(1); explosionAnimation.play(); pane.getChildren().addAll(explosionImage); explosionAnimation.setOnFinished( event -> { pane.getChildren().remove(explosionImage); log.warn("Removed"); } ); } Explosion(double scale, ImageView imageView); @Override void execute(Pane pane); }	@Test public void execute() throws Exception { Pane pane = mock(Pane.class); LinkedList<Node> paneChildren = new LinkedList<>(); when(pane.getChildren()).thenReturn(new ObservableListWrapper<>(paneChildren)); ImageView imageView = mock(ImageView.class); Explosion explosion = new Explosion(0.5, imageView); explosion.execute(pane); Assert.assertThat(paneChildren, hasSize(greaterThan(0))); }
BaseEntity { void updateUI() { setSpriteX(position.getX() - imageView.getFitWidth() / 2); setSpriteY(position.getY() - imageView.getFitHeight() / 2); imageView.relocate(getSpriteX(), getSpriteY()); imageView.setRotate(getRotation()); imageView.setScaleX(getScale()); imageView.setScaleY(getScale()); } BaseEntity(BlockingQueue<UIUpdate> uiUpdates, String image); void setPosition(D3Vector position); void setDirection(D3PolarCoordinate direction); double getSpriteX(); void setSpriteX(double spriteX); double getSpriteY(); void setSpriteY(double spriteY); String getId(); void setId(String id); void delete(); }	@Test public void testUpdateUI() throws Exception { D3Vector position = new D3Vector(150, 100, 500); baseEntity.setPosition(position); D3PolarCoordinate direction = new D3PolarCoordinate(0.25 * Math.PI, 0.5 * Math.PI, 100); baseEntity.setDirection(direction); baseEntity.updateUI(); Assert.assertEquals(150, baseEntity.getSpriteX(), 0.1); Assert.assertEquals(100, baseEntity.getSpriteY(), 0.1); Assert.assertEquals(150, baseEntity.imageView.getLayoutX(), 0.1); Assert.assertEquals(100, baseEntity.imageView.getLayoutY(), 0.1); Assert.assertEquals(45, baseEntity.imageView.getRotate(), 0.1); Assert.assertEquals(0.55, baseEntity.imageView.getScaleX(), 0.1); Assert.assertEquals(0.55, baseEntity.imageView.getScaleY(), 0.1); }
Radar implements Subscriber { public void start() { List<NodeEventHandler<RemovedNode>> removedNodeHandlers = new ArrayList<>(); removedNodeHandlers.add((RemovedNode e) -> { DiscoveryNode node = e.getNode(); DiscoveryPath path = node.getPath(); if (path.startsWith(DiscoveryPath.type(Type.DRONE)) && path.isConfigPath()) { String protocolId = node.getId(); this.allEntities.remove(protocolId); } }); this.discoverer.addHandlers(true, Collections.emptyList(), Collections.emptyList(), removedNodeHandlers); architectureEventController.addHandler(SimulationState.INIT, SimulationAction.CONFIG, SimulationState.CONFIG, (fromState, action, toState) -> allEntities.clear()); } Radar(); Radar(ArchitectureEventController architectureEventController, DroneInit drone, Discoverer discoverer, D3Vector position); Radar(Radar copy); D3Vector getPosition(); void setPosition(D3Vector position); void start(); List<D3Vector> getRadar(); Optional<D3Vector> getNearestTarget(); @Override void receive(Object msg, MultipartCallbacks multipartCallbacks); @Override boolean equals(Object o); @Override int hashCode(); static final int RADAR_RANGE; }	@Test public void testStart() throws Exception { radar.start(); Map<String, D3Vector> allEntities = new ConcurrentHashMap<>(); setField(radar, "allEntities", allEntities); allEntities.put("drone-id", D3Vector.ZERO); Assert.assertThat(discoverer.getRemovedHandlers().size(), is(1)); DiscoveryNode node = new DiscoveryNode("drone-id", new DiscoveryNode("root"), DiscoveryPath.config(Type.DRONE, Group.DRONE, "name")); RemovedNode removedNode = new RemovedNode(node); discoverer.getRemovedHandlers().get(0).handle(removedNode); Assert.assertThat(allEntities.values(), not(hasItem(D3Vector.ZERO))); Assert.assertThat(allEntities.size(), is(0)); Radar radarStateBefore = new Radar(radar); removedNode = new RemovedNode(new DiscoveryNode("random node", new DiscoveryNode("root"), DiscoveryPath.config(Type.SERVICE, Group.TACTIC, "some tactic"))); discoverer.getRemovedHandlers().get(0).handle(removedNode); Assert.assertThat(radarStateBefore, is(radar)); }
BaseEntity { public void delete() { uiUpdates.add(new RemoveBaseEntity(imageView)); } BaseEntity(BlockingQueue<UIUpdate> uiUpdates, String image); void setPosition(D3Vector position); void setDirection(D3PolarCoordinate direction); double getSpriteX(); void setSpriteX(double spriteX); double getSpriteY(); void setSpriteY(double spriteY); String getId(); void setId(String id); void delete(); }	@Test public void testDelete() throws Exception { int sizeBefore = uiUpdates.size(); baseEntity.delete(); int sizeAfter = uiUpdates.size(); Assert.assertEquals(sizeBefore + 1, sizeAfter); Assert.assertTrue(uiUpdates.contains(new RemoveBaseEntity(baseEntity.imageView))); }
ArchitectureButtonEventHandler implements EventHandler<MouseEvent> { @Override public void handle(MouseEvent event) { RequestArchitectureStateChangeMessage msg = new RequestArchitectureStateChangeMessage(action); publisher.send(msg); } ArchitectureButtonEventHandler(SimulationAction action, Publisher publisher); @Override void handle(MouseEvent event); }	@Test public void testHandle() { handler.handle(mock(MouseEvent.class)); Assert.assertTrue(publisher.isMessageReceived(MessageTopic.ARCHITECTURE, new RequestArchitectureStateChangeMessage(SimulationAction.INIT))); }
TimeoutTimer { public static boolean isTimeExceeded(long startTime, double timeout) { return (startTime + timeout) < System.currentTimeMillis(); } TimeoutTimer(double timeout); static boolean isTimeExceeded(long startTime, double timeout); static boolean isTimeExceeded(LocalDateTime startTime, long timeout); static boolean isTimeExceeded(LocalDateTime startTime, double timeout); synchronized void reset(); synchronized boolean timeIsExceeded(); }	@Test public void isTimeExceeded() throws Exception { long testDelta = 1000; long oldTime = System.currentTimeMillis() - testDelta; Assert.assertTrue(TimeoutTimer.isTimeExceeded(oldTime, testDelta * 0.5)); Assert.assertFalse(TimeoutTimer.isTimeExceeded(oldTime, testDelta * 2)); } @Test public void isTimeExceeded1() throws Exception { long testDelta = 1000; LocalDateTime oldTime = LocalDateTime.now().minusSeconds(testDelta); Assert.assertTrue(TimeoutTimer.isTimeExceeded(oldTime, (long) (testDelta * 0.5))); Assert.assertFalse(TimeoutTimer.isTimeExceeded(oldTime, testDelta * 2)); Assert.assertTrue(TimeoutTimer.isTimeExceeded(oldTime, (testDelta * 0.5))); Assert.assertFalse(TimeoutTimer.isTimeExceeded(oldTime, testDelta * 2.0)); double testDeltaDouble = 0.005; oldTime = LocalDateTime.now().minusNanos((long) (testDeltaDouble * 1e9)); Assert.assertTrue(TimeoutTimer.isTimeExceeded(oldTime, (testDeltaDouble * 0.5))); Assert.assertFalse(TimeoutTimer.isTimeExceeded(oldTime, testDeltaDouble * 2.0)); }
D2Vector { public D2Vector add(D2Vector other) { return new D2Vector(this.getX() + other.getX(), this.getY() + other.getY()); } D2Vector(double x, double y); D2Vector(); double getX(); double getY(); D2Vector add(D2Vector other); D2Vector sub(D2Vector other); double length(); D2Vector scale(double scalar); @Override boolean equals(Object o); @Override int hashCode(); static final D2Vector UNIT; }	@Test public void add() throws Exception { Assert.assertEquals(new D2Vector(5, 7), vector1.add(vector2)); }
D2Vector { public D2Vector sub(D2Vector other) { return new D2Vector(this.getX() - other.getX(), this.getY() - other.getY()); } D2Vector(double x, double y); D2Vector(); double getX(); double getY(); D2Vector add(D2Vector other); D2Vector sub(D2Vector other); double length(); D2Vector scale(double scalar); @Override boolean equals(Object o); @Override int hashCode(); static final D2Vector UNIT; }	@Test public void sub() throws Exception { Assert.assertEquals(new D2Vector(1, 1), vector3.sub(vector2)); }
D2Vector { public double length() { return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2)); } D2Vector(double x, double y); D2Vector(); double getX(); double getY(); D2Vector add(D2Vector other); D2Vector sub(D2Vector other); double length(); D2Vector scale(double scalar); @Override boolean equals(Object o); @Override int hashCode(); static final D2Vector UNIT; }	@Test public void length() throws Exception { Assert.assertEquals(5, vector2.length(), 0.1); }
D2Vector { public D2Vector scale(double scalar) { return new D2Vector(this.getX() * scalar, this.getY() * scalar); } D2Vector(double x, double y); D2Vector(); double getX(); double getY(); D2Vector add(D2Vector other); D2Vector sub(D2Vector other); double length(); D2Vector scale(double scalar); @Override boolean equals(Object o); @Override int hashCode(); static final D2Vector UNIT; }	@Test public void scale() throws Exception { Assert.assertEquals(new D2Vector(4, 6), vector1.scale(2)); }
Settings { public static double getTickTime(ChronoUnit temporalUnit) { switch (temporalUnit) { case NANOS: return getTickTime(ChronoUnit.MICROS) * 1000d; case MICROS: return getTickTime(ChronoUnit.MILLIS) * 1000d; case MILLIS: return TICK_TIME; case SECONDS: return getTickTime(ChronoUnit.MILLIS) / 1000d; case MINUTES: return getTickTime(ChronoUnit.SECONDS) / 60d; case HOURS: return getTickTime(ChronoUnit.MINUTES) / 60d; default: throw new IllegalArgumentException(temporalUnit.name() + " is not (yet) supported"); } } private Settings(); static double getTickTime(ChronoUnit temporalUnit); static final String ETCD_HOST; static final String ETCD_PORT; static final double ARENA_HEIGHT; static final double ARENA_DEPTH; static final double ARENA_WIDTH; static final D3Vector ARENA; static final GameMode GAME_MODE; static final long TICK_TIME; static final double MAX_DRONE_ACCELERATION; static final double MAX_DRONE_VELOCITY; }	@Test public void getTickTime() throws Exception { Assert.assertEquals(Settings.TICK_TIME, Settings.getTickTime(ChronoUnit.MILLIS), 0.1); Assert.assertEquals(Settings.TICK_TIME / 1000, Settings.getTickTime(ChronoUnit.SECONDS), 0.1); Assert.assertEquals(Settings.TICK_TIME * 1000, Settings.getTickTime(ChronoUnit.MICROS), 0.1); }
Radar implements Subscriber { public List<D3Vector> getRadar() { List<D3Vector> results; if (position != null) { results = allEntities.values() .parallelStream() .filter(otherDrone -> position.distance_between(otherDrone) <= RADAR_RANGE) .collect(Collectors.toList()); } else { results = Collections.emptyList(); } return new ArrayList<>(results); } Radar(); Radar(ArchitectureEventController architectureEventController, DroneInit drone, Discoverer discoverer, D3Vector position); Radar(Radar copy); D3Vector getPosition(); void setPosition(D3Vector position); void start(); List<D3Vector> getRadar(); Optional<D3Vector> getNearestTarget(); @Override void receive(Object msg, MultipartCallbacks multipartCallbacks); @Override boolean equals(Object o); @Override int hashCode(); static final int RADAR_RANGE; }	@Test public void testGetRadar() throws Exception { Map<String, D3Vector> allEntities = new ConcurrentHashMap<>(); setField(radar, "allEntities", allEntities); allEntities.put("in-range", new D3Vector(100, 100, 100)); Assert.assertThat(radar.getRadar(), hasItems(allEntities.values().toArray(new D3Vector[allEntities.size()]))); allEntities.put("Out-of-range", new D3Vector(800, 800, 800)); Assert.assertThat(radar.getRadar(), not(hasItem(new D3Vector(800, 800, 800)))); setField(radar, "position", null); Assert.assertEquals(Collections.emptyList(), radar.getRadar()); }
Radar implements Subscriber { public Optional<D3Vector> getNearestTarget() { return getRadar() .parallelStream().min(Comparator.comparingDouble(e -> e.distance_between(position))); } Radar(); Radar(ArchitectureEventController architectureEventController, DroneInit drone, Discoverer discoverer, D3Vector position); Radar(Radar copy); D3Vector getPosition(); void setPosition(D3Vector position); void start(); List<D3Vector> getRadar(); Optional<D3Vector> getNearestTarget(); @Override void receive(Object msg, MultipartCallbacks multipartCallbacks); @Override boolean equals(Object o); @Override int hashCode(); static final int RADAR_RANGE; }	@Test public void testGetNearestTarget() throws Exception { Map<String, D3Vector> allEntities = new ConcurrentHashMap<>(); setField(radar, "allEntities", allEntities); allEntities.put("far", new D3Vector(100, 100, 100)); allEntities.put("near", new D3Vector(10, 10, 10)); allEntities.put("Out-of-range", new D3Vector(800, 800, 800)); Optional<D3Vector> target = radar.getNearestTarget(); if (target.isPresent()) { Assert.assertThat(target.get(), is(new D3Vector(10, 10, 10))); } else { Assert.fail("No nearest target found"); } }
Engine { public static D3Vector limit_acceleration(D3Vector input) { D3Vector output = input; if (input.length() > Settings.MAX_DRONE_ACCELERATION) { double correctionFactor = Settings.MAX_DRONE_ACCELERATION / input.length(); output = input.scale(correctionFactor); } return output; } Engine(); Engine(Publisher m_publisher, GPS m_gps, DroneInit m_drone, D3Vector lastAcceleration); D3Vector getLastAcceleration(); static D3Vector limit_acceleration(D3Vector input); static D3Vector maximize_acceleration(D3Vector input); D3Vector stagnate_acceleration(D3Vector input); void changeAcceleration(D3Vector input_acceleration); D3Vector changeVelocity(D3Vector input); final void registerCallback(EngineCallback callback); }	@Test public void limit_acceleration() throws Exception { Assert.assertEquals(new D3Vector(0, 0, 0), Engine.limit_acceleration(new D3Vector(0, 0, 0))); Assert.assertEquals(new D3Vector(5, 5, 5), Engine.limit_acceleration(new D3Vector(5, 5, 5))); Assert.assertEquals(new D3Vector(-5, -5, -5), Engine.limit_acceleration(new D3Vector(-5, -5, -5))); Assert.assertEquals(new D3Vector(-5, 5, -5), Engine.limit_acceleration(new D3Vector(-5, 5, -5))); Assert.assertEquals(new D3Vector(-5, 5, 5), Engine.limit_acceleration(new D3Vector(-5, 5, 5))); Assert.assertEquals(new D3Vector(10, 0, 0), Engine.limit_acceleration(new D3Vector(1000, 0, 0))); Assert.assertEquals(new D3Vector(-10, 0, 0), Engine.limit_acceleration(new D3Vector(-1000, 0, 0))); }
Engine { public static D3Vector maximize_acceleration(D3Vector input) { D3Vector output = input; if (input.length() < Settings.MAX_DRONE_ACCELERATION && input.length() != 0) { double correctionFactor = Settings.MAX_DRONE_ACCELERATION / input.length(); output = input.scale(correctionFactor); } return output; } Engine(); Engine(Publisher m_publisher, GPS m_gps, DroneInit m_drone, D3Vector lastAcceleration); D3Vector getLastAcceleration(); static D3Vector limit_acceleration(D3Vector input); static D3Vector maximize_acceleration(D3Vector input); D3Vector stagnate_acceleration(D3Vector input); void changeAcceleration(D3Vector input_acceleration); D3Vector changeVelocity(D3Vector input); final void registerCallback(EngineCallback callback); }	@Test public void maximize_acceleration() throws Exception { Assert.assertEquals(new D3Vector(0, 0, 0), Engine.maximize_acceleration(new D3Vector(0, 0, 0))); Assert.assertEquals(new D3Vector(5.77350269189625764509148780501957, 5.77350269189625764509148780501957, 5.77350269189625764509148780501957), Engine.maximize_acceleration(new D3Vector(5, 5, 5))); Assert.assertEquals(new D3Vector(15, 15, 15), Engine.maximize_acceleration(new D3Vector(15, 15, 15))); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.