private void addRegionToMap(Map<ServerName, List<RegionInfo>> assignmentMapForFavoredNodes, RegionInfo region, ServerName host) { List<RegionInfo> regionsOnServer; if ((regionsOnServer = assignmentMapForFavoredNodes.get(host)) == null) { regionsOnServer = Lists.newArrayList(); assignmentMapForFavoredNodes.put(host, regionsOnServer); } regionsOnServer.add(region); }
TaskMonitor(Configuration conf) { maxTasks = conf.getInt(MAX_TASKS_KEY, DEFAULT_MAX_TASKS); expirationTime = conf.getLong(EXPIRATION_TIME_KEY, DEFAULT_EXPIRATION_TIME); rpcWarnTime = conf.getLong(RPC_WARN_TIME_KEY, DEFAULT_RPC_WARN_TIME); tasks = new CircularFifoQueue(maxTasks); rpcTasks = Lists.newArrayList(); monitorInterval = conf.getLong(MONITOR_INTERVAL_KEY, DEFAULT_MONITOR_INTERVAL); monitorThread = new Thread(new MonitorRunnable()); Threads.setDaemonThreadRunning(monitorThread, "Monitor thread for TaskMonitor"); }
private void initializeWALEntryFilter(UUID peerClusterId) { // get the WALEntryFilter from ReplicationEndpoint and add it to default filters ArrayList<WALEntryFilter> filters = Lists.<WALEntryFilter> newArrayList(new SystemTableWALEntryFilter()); WALEntryFilter filterFromEndpoint = this.replicationEndpoint.getWALEntryfilter(); if (filterFromEndpoint != null) { filters.add(filterFromEndpoint); } filters.add(new ClusterMarkingEntryFilter(clusterId, peerClusterId, replicationEndpoint)); this.walEntryFilter = new ChainWALEntryFilter(filters); }
private void runTestAtomicity(long millisToRun, int numWriters, int numGetters, int numScanners, int numUniqueRows, boolean useMob) throws Exception { List<String> args = Lists.newArrayList("-millis", String.valueOf(millisToRun), "-numWriters", String.valueOf(numWriters), "-numGetters", String.valueOf(numGetters), "-numScanners", String.valueOf(numScanners), "-numUniqueRows", String.valueOf(numUniqueRows), "-crazyFlush"); if (useMob) { args.add("-useMob"); } tool.run(args.toArray(new String[0])); }
@Override public ServerName randomAssignment(RegionInfo region, List<ServerName> servers) throws HBaseIOException { ListMultimap<String,RegionInfo> regionMap = LinkedListMultimap.create(); ListMultimap<String,ServerName> serverMap = LinkedListMultimap.create(); generateGroupMaps(Lists.newArrayList(region), servers, regionMap, serverMap); List<ServerName> filteredServers = serverMap.get(regionMap.keySet().iterator().next()); return this.internalBalancer.randomAssignment(region, filteredServers); }
public Map<String, Collection<ScanWithEquals>> toScanWithEquals( Map<String, Collection<Scan>> snapshotScans) throws IOException { Map<String, Collection<ScanWithEquals>> rtn = Maps.newHashMap(); for (Map.Entry<String, Collection<Scan>> entry : snapshotScans.entrySet()) { List<ScanWithEquals> scans = Lists.newArrayList(); for (Scan scan : entry.getValue()) { scans.add(new ScanWithEquals(scan)); } rtn.put(entry.getKey(), scans); } return rtn; }
@Override public Object run() throws Exception { List<TableName> tableNamesList = Lists.newArrayList(); tableNamesList.add(TEST_TABLE.getTableName()); List<TableDescriptor> descriptors = Lists.newArrayList(); ACCESS_CONTROLLER.preGetTableDescriptors(ObserverContextImpl.createAndPrepare(CP_ENV), tableNamesList, descriptors, ".+"); return null; } }, SUPERUSER, USER_ADMIN, USER_RW, USER_RO, USER_OWNER, USER_CREATE, USER_QUAL, USER_NONE);
private List<CoprocessorViolation> validateClass(ClassLoader classLoader, String className) { List<String> classNames = Lists.newArrayList(getFullClassName(className)); List<CoprocessorViolation> violations = new ArrayList<>(); validator.validateClasses(classLoader, classNames, violations); return violations; }
@Override protected void configureGenerators() { List<CandidateGenerator> fnPickers = Lists.newArrayList(); fnPickers.add(new FavoredNodeLoadPicker()); setCandidateGenerators(fnPickers); } }
@Override public Object run() throws Exception { List<Cell> cells = Lists.newArrayList(); ACCESS_CONTROLLER.preGetOp(ObserverContextImpl.createAndPrepare(RCP_ENV), new Get(TEST_ROW), cells); return null; } }, SUPERUSER, USER_ADMIN, USER_RW, USER_RO, USER_OWNER, USER_CREATE, USER_QUAL, USER_NONE);
public static void assertErrors(HBaseFsck fsck, ERROR_CODE[] expectedErrors) { List<ERROR_CODE> errs = fsck.getErrors().getErrorList(); Collections.sort(errs); List<ERROR_CODE> expErrs = Lists.newArrayList(expectedErrors); Collections.sort(expErrs); assertEquals(expErrs, errs); } }
@Override public Object run() throws Exception { List<NamespaceDescriptor> descriptors = Lists.newArrayList(); ACCESS_CONTROLLER.preListNamespaceDescriptors(ObserverContextImpl.createAndPrepare(CP_ENV), descriptors); return null; } }, SUPERUSER, USER_ADMIN, USER_RW, USER_RO, USER_OWNER, USER_CREATE, USER_QUAL, USER_NONE);
@Override public Object run() throws Exception { List<TableDescriptor> descriptors = Lists.newArrayList(); ACCESS_CONTROLLER.preGetTableNames(ObserverContextImpl.createAndPrepare(CP_ENV), descriptors, ".+"); return null; } }, SUPERUSER, USER_ADMIN, USER_RW, USER_RO, USER_OWNER, USER_CREATE, USER_QUAL, USER_NONE);
@Before public void setUp() throws IOException { Configuration conf = HBaseConfiguration.create(); conf.set(RpcServerFactory.CUSTOM_RPC_SERVER_IMPL_CONF_KEY, rpcServerImpl.getName()); server = RpcServerFactory.createRpcServer(null, "testRpcServer", Lists.newArrayList(new BlockingServiceAndInterface(SERVICE, null)), new InetSocketAddress("localhost", 0), conf, new FifoRpcScheduler(conf, 1)); server.start(); socket = new Socket("localhost", server.getListenerAddress().getPort()); }
@Test public void testLoadSinleInstance() { MetricRegistries loader = mock(MetricRegistries.class); MetricRegistries instance = MetricRegistriesLoader.load(Lists.newArrayList(loader)); assertEquals(loader, instance); }
private void archiveStoreFile(int index) throws IOException { Collection<HStoreFile> files = this.store.getStorefiles(); HStoreFile sf = null; Iterator<HStoreFile> it = files.iterator(); for (int i = 0; i <= index; i++) { sf = it.next(); } store.getRegionFileSystem().removeStoreFiles(store.getColumnFamilyName(), Lists.newArrayList(sf)); }
private List<byte[]> getRegionsByServer(int rsId) throws IOException { List<byte[]> regionNames = Lists.newArrayList(); HRegionServer hrs = getRegionServer(rsId); for (Region r : hrs.getRegions(TABLE_NAME)) { regionNames.add(r.getRegionInfo().getRegionName()); } return regionNames; }
@Test public void testKeySet() { map.put("foo", () -> "foovalue"); map.put("bar", () -> "foovalue2"); map.put("baz", () -> "foovalue3"); Set<String> keys = map.keySet(); assertEquals(3, keys.size()); Lists.newArrayList("foo", "bar", "baz").stream().forEach(v -> assertTrue(keys.contains(v))); }
@Test public void testValues() { map.put("foo", () -> "foovalue"); map.put("foo", () -> "foovalue2"); map.put("bar", () -> "foovalue3"); map.put("baz", () -> "foovalue4"); Collection<String> values = map.values(); assertEquals(3, values.size()); Lists.newArrayList("foovalue", "foovalue3", "foovalue4").stream() .forEach(v -> assertTrue(values.contains(v))); } }
private static List<AccessController> getAccessControllers(MiniHBaseCluster cluster) { List<AccessController> result = Lists.newArrayList(); for (RegionServerThread t: cluster.getLiveRegionServerThreads()) { for (HRegion region: t.getRegionServer().getOnlineRegionsLocalContext()) { Coprocessor cp = region.getCoprocessorHost().findCoprocessor(AccessController.class); if (cp != null) { result.add((AccessController)cp); } } } return result; }