private AcceptPredicate(Set<MediaType> mediaTypes) { super(headers -> { List<MediaType> acceptedMediaTypes = acceptedMediaTypes(headers); boolean match = acceptedMediaTypes.stream() .anyMatch(acceptedMediaType -> mediaTypes.stream() .anyMatch(acceptedMediaType::isCompatibleWith)); traceMatch("Accept", mediaTypes, acceptedMediaTypes, match); return match; }); this.mediaTypes = mediaTypes; }
private static Map<String, PartitionStatistics> getPartitionsStatistics(SemiTransactionalHiveMetastore metastore, SchemaTableName table, List<HivePartition> hivePartitions) { if (hivePartitions.isEmpty()) { return ImmutableMap.of(); } boolean unpartitioned = hivePartitions.stream().anyMatch(partition -> partition.getPartitionId().equals(UNPARTITIONED_ID)); if (unpartitioned) { checkArgument(hivePartitions.size() == 1, "expected only one hive partition"); return ImmutableMap.of(UNPARTITIONED_ID, metastore.getTableStatistics(table.getSchemaName(), table.getTableName())); } Set<String> partitionNames = hivePartitions.stream() .map(HivePartition::getPartitionId) .collect(toImmutableSet()); return metastore.getPartitionStatistics(table.getSchemaName(), table.getTableName(), partitionNames); }
private static void validatePropertySet(SetRequest request, @Nullable PropertyDefinition definition) { checkRequest(definition != null, "Setting '%s' is undefined", request.getKey()); checkRequest(PropertyType.PROPERTY_SET.equals(definition.type()), "Parameter '%s' is used for setting of property set type only", PARAM_FIELD_VALUES); Set<String> fieldKeys = definition.fields().stream().map(PropertyFieldDefinition::key).collect(Collectors.toSet()); ListMultimap<String, String> valuesByFieldKeys = ArrayListMultimap.create(fieldKeys.size(), request.getFieldValues().size() * fieldKeys.size()); request.getFieldValues().stream() .map(oneFieldValues -> readOneFieldValues(oneFieldValues, request.getKey())) .peek(map -> checkRequest(map.values().stream().anyMatch(StringUtils::isNotBlank), MSG_NO_EMPTY_VALUE)) .flatMap(map -> map.entrySet().stream()) .peek(entry -> valuesByFieldKeys.put(entry.getKey(), entry.getValue())) .forEach(entry -> checkRequest(fieldKeys.contains(entry.getKey()), "Unknown field key '%s' for setting '%s'", entry.getKey(), request.getKey())); checkFieldType(request, definition, valuesByFieldKeys); }
@Test public void testHandleDeadWorker() throws Exception { Table table = TEST_UTIL.createTable(TABLE_NAME, FAMILY, TEST_UTIL.KEYS_FOR_HBA_CREATE_TABLE); for (int i = 0; i < 10; i++) { TEST_UTIL.loadTable(table, FAMILY); } HRegionServer testServer = TEST_UTIL.getHBaseCluster().getRegionServer(0); ProcedureExecutor<MasterProcedureEnv> masterPE = master.getMasterProcedureExecutor(); List<FileStatus> wals = splitWALManager.getWALsToSplit(testServer.getServerName(), false); Assert.assertEquals(1, wals.size()); TEST_UTIL.getHBaseCluster().killRegionServer(testServer.getServerName()); TEST_UTIL.waitFor(30000, () -> master.getProcedures().stream() .anyMatch(procedure -> procedure instanceof SplitWALProcedure)); Procedure splitWALProcedure = master.getProcedures().stream() .filter(procedure -> procedure instanceof SplitWALProcedure).findAny().get(); Assert.assertNotNull(splitWALProcedure); TEST_UTIL.waitFor(5000, () -> ((SplitWALProcedure) splitWALProcedure).getWorker() != null); TEST_UTIL.getHBaseCluster() .killRegionServer(((SplitWALProcedure) splitWALProcedure).getWorker()); ProcedureTestingUtility.waitProcedure(masterPE, splitWALProcedure.getProcId()); Assert.assertTrue(splitWALProcedure.isSuccess()); ProcedureTestingUtility.waitAllProcedures(masterPE); }
@Test public void testCommandManagerLoadsUserCommand() throws Exception { Properties props = new Properties(); props.setProperty(ConfigurationProperties.USER_COMMAND_PACKAGES, "com.examples"); CommandManager commandManager = new CommandManager(props, null); assertThat( commandManager.getCommandMarkers().stream().anyMatch(c -> c instanceof UserGfshCommand)); }
private void validate(short version, List<AclBindingFilter> filters) { if (version == 0) { final boolean unsupported = filters.stream() .map(AclBindingFilter::patternFilter) .map(ResourcePatternFilter::patternType) .anyMatch(patternType -> patternType != PatternType.LITERAL && patternType != PatternType.ANY); if (unsupported) { throw new UnsupportedVersionException("Version 0 only supports literal resource pattern types"); } } final boolean unknown = filters.stream().anyMatch(AclBindingFilter::isUnknown); if (unknown) { throw new IllegalArgumentException("Filters contain UNKNOWN elements"); } } }
public WebUserTokenInterceptor(UserTokenManager userTokenManager, List<UserTokenParser> userTokenParser,AopMethodAuthorizeDefinitionParser definitionParser) { this.userTokenManager = userTokenManager; this.userTokenParser = userTokenParser; this.parser=definitionParser; enableBasicAuthorization = userTokenParser.stream() .filter(UserTokenForTypeParser.class::isInstance) .anyMatch(parser -> "basic".equalsIgnoreCase(((UserTokenForTypeParser) parser).getTokenType())); }
public static boolean dependsOn(WindowNode parent, WindowNode child) { return parent.getPartitionBy().stream().anyMatch(child.getCreatedSymbols()::contains) || (parent.getOrderingScheme().isPresent() && parent.getOrderingScheme().get().getOrderBy().stream().anyMatch(child.getCreatedSymbols()::contains)) || parent.getWindowFunctions().values().stream() .map(WindowNode.Function::getFunctionCall) .map(SymbolsExtractor::extractUnique) .flatMap(Collection::stream) .anyMatch(child.getCreatedSymbols()::contains); } }