Examples with Collections.singletonList java.util.Collections.singletonList used on opensource projects

Example 11 with Collections.singletonList

use of java.util.Collections.singletonList in project karaf by apache.

the class Builder method bootStage.

private Set<Feature> bootStage(Profile bootProfile, Profile startupEffective, FeaturesProcessor processor) throws Exception {
    LOGGER.info("Boot stage");
    // 
    // Handle boot profiles
    // 
    Profile bootOverlay = Profiles.getOverlay(bootProfile, allProfiles, environment);
    Profile bootEffective = Profiles.getEffective(bootOverlay, false);
    // Load startup repositories
    LOGGER.info("   Loading boot repositories");
    Map<String, Features> bootRepositories = loadRepositories(manager, bootEffective.getRepositories(), true, processor);
    // Compute startup feature dependencies
    Set<Feature> allBootFeatures = new HashSet<>();
    for (Features repo : bootRepositories.values()) {
        allBootFeatures.addAll(repo.getFeature());
    }
    // Generate a global feature
    Map<String, Dependency> generatedDep = new HashMap<>();
    Feature generated = new Feature();
    generated.setName(UUID.randomUUID().toString());
    // Add feature dependencies
    for (String nameOrPattern : bootEffective.getFeatures()) {
        // KARAF-5273: feature may be a pattern
        for (String dependency : FeatureSelector.getMatchingFeatures(nameOrPattern, bootRepositories.values())) {
            Dependency dep = generatedDep.get(dependency);
            if (dep == null) {
                dep = createDependency(dependency);
                generated.getFeature().add(dep);
                generatedDep.put(dep.getName(), dep);
            }
            dep.setDependency(false);
        }
    }
    // Add bundles
    for (String location : bootEffective.getBundles()) {
        location = location.replace("profile:", "file:etc/");
        Bundle bun = new Bundle();
        bun.setLocation(location);
        generated.getBundle().add(bun);
    }
    Features rep = new Features();
    rep.setName(UUID.randomUUID().toString());
    rep.getRepository().addAll(bootEffective.getRepositories());
    rep.getFeature().add(generated);
    allBootFeatures.add(generated);
    Downloader downloader = manager.createDownloader();
    // Compute startup feature dependencies
    FeatureSelector selector = new FeatureSelector(allBootFeatures);
    Set<Feature> bootFeatures = selector.getMatching(singletonList(generated.getName()));
    for (Feature feature : bootFeatures) {
        if (feature.isBlacklisted()) {
            LOGGER.info("   Feature " + feature.getId() + " is blacklisted, ignoring");
            continue;
        }
        LOGGER.info("   Feature " + feature.getId() + " is defined as a boot feature");
        // add the feature in the system folder
        Set<BundleInfo> bundleInfos = new HashSet<>();
        for (Bundle bundle : feature.getBundle()) {
            if (!ignoreDependencyFlag || !bundle.isDependency()) {
                bundleInfos.add(bundle);
            }
        }
        for (Conditional cond : feature.getConditional()) {
            if (cond.isBlacklisted()) {
                LOGGER.info("   Conditionial " + cond.getConditionId() + " is blacklisted, ignoring");
            }
            for (Bundle bundle : cond.getBundle()) {
                if (!ignoreDependencyFlag || !bundle.isDependency()) {
                    bundleInfos.add(bundle);
                }
            }
        }
        // Build optional features and known prerequisites
        Map<String, List<String>> prereqs = new HashMap<>();
        prereqs.put("blueprint:", Arrays.asList("deployer", "aries-blueprint"));
        prereqs.put("spring:", Arrays.asList("deployer", "spring"));
        prereqs.put("wrap:", Collections.singletonList("wrap"));
        prereqs.put("war:", Collections.singletonList("war"));
        ArtifactInstaller installer = new ArtifactInstaller(systemDirectory, downloader, blacklist);
        for (BundleInfo bundleInfo : bundleInfos) {
            installer.installArtifact(bundleInfo);
            for (Map.Entry<String, List<String>> entry : prereqs.entrySet()) {
                if (bundleInfo.getLocation().trim().startsWith(entry.getKey())) {
                    for (String prereq : entry.getValue()) {
                        Dependency dep = generatedDep.get(prereq);
                        if (dep == null) {
                            dep = new Dependency();
                            dep.setName(prereq);
                            generated.getFeature().add(dep);
                            generatedDep.put(dep.getName(), dep);
                        }
                        dep.setPrerequisite(true);
                    }
                }
            }
        }
        new ConfigInstaller(etcDirectory, pidsToExtract).installConfigs(feature, downloader, installer);
        // Install libraries
        List<String> libraries = new ArrayList<>();
        for (Library library : feature.getLibraries()) {
            String lib = library.getLocation() + ";type:=" + library.getType() + ";export:=" + library.isExport() + ";delegate:=" + library.isDelegate();
            libraries.add(lib);
        }
        Path configPropertiesPath = etcDirectory.resolve("config.properties");
        Properties configProperties = new Properties(configPropertiesPath.toFile());
        downloadLibraries(downloader, configProperties, libraries, "   ");
        downloader.await();
        // Reformat clauses
        reformatClauses(configProperties, Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA);
        reformatClauses(configProperties, Constants.FRAMEWORK_BOOTDELEGATION);
        configProperties.save();
    }
    // If there are bundles to install, we can't use the boot features only
    // so keep the generated feature
    Path featuresCfgFile = etcDirectory.resolve("org.apache.karaf.features.cfg");
    if (!generated.getBundle().isEmpty()) {
        File output = etcDirectory.resolve(rep.getName() + ".xml").toFile();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        JaxbUtil.marshal(rep, baos);
        ByteArrayInputStream bais;
        String repoUrl;
        if (karafVersion == KarafVersion.v24) {
            String str = baos.toString();
            str = str.replace("http://karaf.apache.org/xmlns/features/v1.3.0", "http://karaf.apache.org/xmlns/features/v1.2.0");
            str = str.replaceAll(" dependency=\".*?\"", "");
            str = str.replaceAll(" prerequisite=\".*?\"", "");
            for (Feature f : rep.getFeature()) {
                for (Dependency d : f.getFeature()) {
                    if (d.isPrerequisite()) {
                        if (!startupEffective.getFeatures().contains(d.getName())) {
                            LOGGER.warn("Feature " + d.getName() + " is a prerequisite and should be installed as a startup feature.");
                        }
                    }
                }
            }
            bais = new ByteArrayInputStream(str.getBytes());
            repoUrl = "file:etc/" + output.getName();
        } else {
            bais = new ByteArrayInputStream(baos.toByteArray());
            repoUrl = "file:${karaf.home}/etc/" + output.getName();
        }
        Files.copy(bais, output.toPath());
        Properties featuresProperties = new Properties(featuresCfgFile.toFile());
        featuresProperties.put(FEATURES_REPOSITORIES, repoUrl);
        featuresProperties.put(FEATURES_BOOT, generated.getName());
        featuresProperties.save();
    } else {
        String repos = getRepos(rep);
        String boot = getBootFeatures(generatedDep);
        Properties featuresProperties = new Properties(featuresCfgFile.toFile());
        featuresProperties.put(FEATURES_REPOSITORIES, repos);
        featuresProperties.put(FEATURES_BOOT, boot);
        reformatClauses(featuresProperties, FEATURES_REPOSITORIES);
        reformatClauses(featuresProperties, FEATURES_BOOT);
        featuresProperties.save();
    }
    downloader.await();
    return allBootFeatures;
}

Example 12 with Collections.singletonList

use of java.util.Collections.singletonList in project apache-kafka-on-k8s by banzaicloud.

the class ConsumerCoordinatorTest method testUpdateMetadataDuringRebalance.

@Test
public void testUpdateMetadataDuringRebalance() {
    final String topic1 = "topic1";
    final String topic2 = "topic2";
    TopicPartition tp1 = new TopicPartition(topic1, 0);
    TopicPartition tp2 = new TopicPartition(topic2, 0);
    final String consumerId = "leader";
    List<String> topics = Arrays.asList(topic1, topic2);
    subscriptions.subscribe(new HashSet<>(topics), rebalanceListener);
    metadata.setTopics(topics);
    // we only have metadata for one topic initially
    metadata.update(TestUtils.singletonCluster(topic1, 1), Collections.<String>emptySet(), time.milliseconds());
    client.prepareResponse(groupCoordinatorResponse(node, Errors.NONE));
    coordinator.ensureCoordinatorReady();
    // prepare initial rebalance
    Map<String, List<String>> memberSubscriptions = singletonMap(consumerId, topics);
    partitionAssignor.prepare(singletonMap(consumerId, Collections.singletonList(tp1)));
    client.prepareResponse(joinGroupLeaderResponse(1, consumerId, memberSubscriptions, Errors.NONE));
    client.prepareResponse(new MockClient.RequestMatcher() {

        @Override
        public boolean matches(AbstractRequest body) {
            SyncGroupRequest sync = (SyncGroupRequest) body;
            if (sync.memberId().equals(consumerId) && sync.generationId() == 1 && sync.groupAssignment().containsKey(consumerId)) {
                // trigger the metadata update including both topics after the sync group request has been sent
                Map<String, Integer> topicPartitionCounts = new HashMap<>();
                topicPartitionCounts.put(topic1, 1);
                topicPartitionCounts.put(topic2, 1);
                metadata.update(TestUtils.singletonCluster(topicPartitionCounts), Collections.<String>emptySet(), time.milliseconds());
                return true;
            }
            return false;
        }
    }, syncGroupResponse(Collections.singletonList(tp1), Errors.NONE));
    // the metadata update should trigger a second rebalance
    client.prepareResponse(joinGroupLeaderResponse(2, consumerId, memberSubscriptions, Errors.NONE));
    client.prepareResponse(syncGroupResponse(Arrays.asList(tp1, tp2), Errors.NONE));
    coordinator.poll(time.milliseconds(), Long.MAX_VALUE);
    assertFalse(coordinator.needRejoin());
    assertEquals(new HashSet<>(Arrays.asList(tp1, tp2)), subscriptions.assignedPartitions());
}

Example 13 with Collections.singletonList

use of java.util.Collections.singletonList in project kafka by apache.

the class KafkaAdminClientTest method testRemoveMembersFromGroup.

@Test
public void testRemoveMembersFromGroup() throws Exception {
    try (AdminClientUnitTestEnv env = mockClientEnv()) {
        final String instanceOne = "instance-1";
        final String instanceTwo = "instance-2";
        env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
        // Retriable FindCoordinatorResponse errors should be retried
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        // Retriable errors should be retried
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())));
        // Inject a top-level non-retriable error
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.UNKNOWN_SERVER_ERROR.code())));
        Collection<MemberToRemove> membersToRemove = Arrays.asList(new MemberToRemove(instanceOne), new MemberToRemove(instanceTwo));
        final RemoveMembersFromConsumerGroupResult unknownErrorResult = env.adminClient().removeMembersFromConsumerGroup(GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
        MemberToRemove memberOne = new MemberToRemove(instanceOne);
        MemberToRemove memberTwo = new MemberToRemove(instanceTwo);
        TestUtils.assertFutureError(unknownErrorResult.memberResult(memberOne), UnknownServerException.class);
        TestUtils.assertFutureError(unknownErrorResult.memberResult(memberTwo), UnknownServerException.class);
        MemberResponse responseOne = new MemberResponse().setGroupInstanceId(instanceOne).setErrorCode(Errors.UNKNOWN_MEMBER_ID.code());
        MemberResponse responseTwo = new MemberResponse().setGroupInstanceId(instanceTwo).setErrorCode(Errors.NONE.code());
        // Inject one member level error.
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(Arrays.asList(responseOne, responseTwo))));
        final RemoveMembersFromConsumerGroupResult memberLevelErrorResult = env.adminClient().removeMembersFromConsumerGroup(GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
        TestUtils.assertFutureError(memberLevelErrorResult.all(), UnknownMemberIdException.class);
        TestUtils.assertFutureError(memberLevelErrorResult.memberResult(memberOne), UnknownMemberIdException.class);
        assertNull(memberLevelErrorResult.memberResult(memberTwo).get());
        // Return with missing member.
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(Collections.singletonList(responseTwo))));
        final RemoveMembersFromConsumerGroupResult missingMemberResult = env.adminClient().removeMembersFromConsumerGroup(GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
        TestUtils.assertFutureError(missingMemberResult.all(), IllegalArgumentException.class);
        // The memberOne was not included in the response.
        TestUtils.assertFutureError(missingMemberResult.memberResult(memberOne), IllegalArgumentException.class);
        assertNull(missingMemberResult.memberResult(memberTwo).get());
        // Return with success.
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(Arrays.asList(responseTwo, new MemberResponse().setGroupInstanceId(instanceOne).setErrorCode(Errors.NONE.code())))));
        final RemoveMembersFromConsumerGroupResult noErrorResult = env.adminClient().removeMembersFromConsumerGroup(GROUP_ID, new RemoveMembersFromConsumerGroupOptions(membersToRemove));
        assertNull(noErrorResult.all().get());
        assertNull(noErrorResult.memberResult(memberOne).get());
        assertNull(noErrorResult.memberResult(memberTwo).get());
        // Test the "removeAll" scenario
        final List<TopicPartition> topicPartitions = Arrays.asList(1, 2, 3).stream().map(partition -> new TopicPartition("my_topic", partition)).collect(Collectors.toList());
        // construct the DescribeGroupsResponse
        DescribeGroupsResponseData data = prepareDescribeGroupsResponseData(GROUP_ID, Arrays.asList(instanceOne, instanceTwo), topicPartitions);
        // Return with partial failure for "removeAll" scenario
        // 1 prepare response for AdminClient.describeConsumerGroups
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
        // 2 KafkaAdminClient encounter partial failure when trying to delete all members
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(Arrays.asList(responseOne, responseTwo))));
        final RemoveMembersFromConsumerGroupResult partialFailureResults = env.adminClient().removeMembersFromConsumerGroup(GROUP_ID, new RemoveMembersFromConsumerGroupOptions());
        ExecutionException exception = assertThrows(ExecutionException.class, () -> partialFailureResults.all().get());
        assertTrue(exception.getCause() instanceof KafkaException);
        assertTrue(exception.getCause().getCause() instanceof UnknownMemberIdException);
        // Return with success for "removeAll" scenario
        // 1 prepare response for AdminClient.describeConsumerGroups
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new DescribeGroupsResponse(data));
        // 2. KafkaAdminClient should delete all members correctly
        env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
        env.kafkaClient().prepareResponse(new LeaveGroupResponse(new LeaveGroupResponseData().setErrorCode(Errors.NONE.code()).setMembers(Arrays.asList(responseTwo, new MemberResponse().setGroupInstanceId(instanceOne).setErrorCode(Errors.NONE.code())))));
        final RemoveMembersFromConsumerGroupResult successResult = env.adminClient().removeMembersFromConsumerGroup(GROUP_ID, new RemoveMembersFromConsumerGroupOptions());
        assertNull(successResult.all().get());
    }
}

Example 14 with Collections.singletonList

use of java.util.Collections.singletonList in project kafka by apache.

the class ConsumerCoordinatorTest method testPerformAssignmentShouldSkipValidateCooperativeAssignmentForBuiltInCooperativeStickyAssignor.

@Test
public void testPerformAssignmentShouldSkipValidateCooperativeAssignmentForBuiltInCooperativeStickyAssignor() {
    SubscriptionState mockSubscriptionState = Mockito.mock(SubscriptionState.class);
    List<JoinGroupResponseData.JoinGroupResponseMember> metadata = validateCooperativeAssignmentTestSetup();
    List<ConsumerPartitionAssignor> assignorsWithCooperativeStickyAssignor = new ArrayList<>(assignors);
    // create a mockPartitionAssignor with the same name as cooperative sticky assignor
    MockPartitionAssignor mockCooperativeStickyAssignor = new MockPartitionAssignor(Collections.singletonList(protocol)) {

        @Override
        public String name() {
            return COOPERATIVE_STICKY_ASSIGNOR_NAME;
        }
    };
    assignorsWithCooperativeStickyAssignor.add(mockCooperativeStickyAssignor);
    // simulate the cooperative sticky assignor do the assignment with out-of-date ownedPartition
    Map<String, List<TopicPartition>> assignment = new HashMap<>();
    assignment.put(consumerId, Arrays.asList(t1p));
    assignment.put(consumerId2, Arrays.asList(t2p));
    mockCooperativeStickyAssignor.prepare(assignment);
    try (ConsumerCoordinator coordinator = buildCoordinator(rebalanceConfig, new Metrics(), assignorsWithCooperativeStickyAssignor, false, mockSubscriptionState)) {
        // should not validate assignment for built-in cooperative sticky assignor
        coordinator.onLeaderElected("1", mockCooperativeStickyAssignor.name(), metadata, false);
    }
}

Example 15 with Collections.singletonList

use of java.util.Collections.singletonList in project kafka by apache.

the class ConsumerCoordinatorTest method testOnLeaderElectedShouldSkipAssignment.

@Test
public void testOnLeaderElectedShouldSkipAssignment() {
    SubscriptionState mockSubscriptionState = Mockito.mock(SubscriptionState.class);
    ConsumerPartitionAssignor assignor = Mockito.mock(ConsumerPartitionAssignor.class);
    String assignorName = "mock-assignor";
    Mockito.when(assignor.name()).thenReturn(assignorName);
    Mockito.when(assignor.supportedProtocols()).thenReturn(Collections.singletonList(protocol));
    Map<String, List<String>> memberSubscriptions = singletonMap(consumerId, singletonList(topic1));
    List<JoinGroupResponseData.JoinGroupResponseMember> metadata = new ArrayList<>();
    for (Map.Entry<String, List<String>> subscriptionEntry : memberSubscriptions.entrySet()) {
        ConsumerPartitionAssignor.Subscription subscription = new ConsumerPartitionAssignor.Subscription(subscriptionEntry.getValue());
        ByteBuffer buf = ConsumerProtocol.serializeSubscription(subscription);
        metadata.add(new JoinGroupResponseData.JoinGroupResponseMember().setMemberId(subscriptionEntry.getKey()).setMetadata(buf.array()));
    }
    try (ConsumerCoordinator coordinator = buildCoordinator(rebalanceConfig, new Metrics(), Collections.singletonList(assignor), false, mockSubscriptionState)) {
        assertEquals(Collections.emptyMap(), coordinator.onLeaderElected("1", assignorName, metadata, true));
        assertTrue(coordinator.isLeader());
    }
    Mockito.verify(assignor, Mockito.never()).assign(Mockito.any(), Mockito.any());
}