Examples with SyncGrainsRunner com.sequenceiq.cloudbreak.orchestrator.salt.poller.checker.SyncGrainsRunner used on opensource projects

Example 1 with SyncGrainsRunner

use of com.sequenceiq.cloudbreak.orchestrator.salt.poller.checker.SyncGrainsRunner in project cloudbreak by hortonworks.

the class SaltOrchestrator method executeRecipes.

@SuppressFBWarnings("REC_CATCH_EXCEPTION")
private void executeRecipes(GatewayConfig gatewayConfig, Set<Node> allNodes, ExitCriteriaModel exitCriteriaModel, RecipeExecutionPhase phase) throws CloudbreakOrchestratorFailedException {
    try (SaltConnector sc = new SaltConnector(gatewayConfig, restDebug)) {
        // add 'recipe' grain to all nodes
        Set<String> targets = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        runSaltCommand(sc, new GrainAddRunner(targets, allNodes, "recipes", phase.value(), CompoundType.IP), exitCriteriaModel);
        // Add Deprecated 'PRE/POST' recipe execution for backward compatibility (since version 2.2.0)
        boolean postRecipe = phase.isPostRecipe();
        if (postRecipe) {
            runSaltCommand(sc, new GrainAddRunner(targets, allNodes, "recipes", RecipeExecutionPhase.POST.value(), CompoundType.IP), exitCriteriaModel);
        } else {
            runSaltCommand(sc, new GrainAddRunner(targets, allNodes, "recipes", RecipeExecutionPhase.PRE.value(), CompoundType.IP), exitCriteriaModel);
        }
        Set<String> all = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        runSaltCommand(sc, new SyncGrainsRunner(all, allNodes), exitCriteriaModel);
        runNewService(sc, new HighStateRunner(all, allNodes), exitCriteriaModel, maxRetryRecipe, false);
        // remove 'recipe' grain from all nodes
        targets = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        runSaltCommand(sc, new GrainRemoveRunner(targets, allNodes, "recipes", phase.value(), CompoundType.IP), exitCriteriaModel);
        // Remove Deprecated 'PRE/POST' recipe execution for backward compatibility (since version 2.2.0)
        if (postRecipe) {
            runSaltCommand(sc, new GrainRemoveRunner(targets, allNodes, "recipes", RecipeExecutionPhase.POST.value(), CompoundType.IP), exitCriteriaModel);
        } else {
            runSaltCommand(sc, new GrainRemoveRunner(targets, allNodes, "recipes", RecipeExecutionPhase.PRE.value(), CompoundType.IP), exitCriteriaModel);
        }
    } catch (Exception e) {
        LOGGER.error("Error occurred during recipe execution", e);
        throw new CloudbreakOrchestratorFailedException(e);
    }
}

Example 2 with SyncGrainsRunner

use of com.sequenceiq.cloudbreak.orchestrator.salt.poller.checker.SyncGrainsRunner in project cloudbreak by hortonworks.

the class SaltOrchestratorTest method runServiceTest.

@Test
public void runServiceTest() throws Exception {
    whenNew(SaltBootstrap.class).withAnyArguments().thenReturn(mock(SaltBootstrap.class));
    whenNew(OrchestratorBootstrapRunner.class).withAnyArguments().thenReturn(mock(OrchestratorBootstrapRunner.class));
    PillarSave pillarSave = mock(PillarSave.class);
    whenNew(PillarSave.class).withAnyArguments().thenReturn(pillarSave);
    GrainAddRunner addRemoveGrainRunner = mock(GrainAddRunner.class);
    whenNew(GrainAddRunner.class).withAnyArguments().thenReturn(addRemoveGrainRunner);
    SaltCommandTracker roleCheckerSaltCommandTracker = mock(SaltCommandTracker.class);
    whenNew(SaltCommandTracker.class).withArguments(eq(saltConnector), eq(addRemoveGrainRunner)).thenReturn(roleCheckerSaltCommandTracker);
    SyncGrainsRunner syncGrainsRunner = mock(SyncGrainsRunner.class);
    whenNew(SyncGrainsRunner.class).withAnyArguments().thenReturn(syncGrainsRunner);
    SaltCommandTracker syncGrainsCheckerSaltCommandTracker = mock(SaltCommandTracker.class);
    whenNew(SaltCommandTracker.class).withArguments(eq(saltConnector), eq(syncGrainsRunner)).thenReturn(syncGrainsCheckerSaltCommandTracker);
    HighStateRunner highStateRunner = mock(HighStateRunner.class);
    whenNew(HighStateRunner.class).withAnyArguments().thenReturn(highStateRunner);
    SaltJobIdTracker saltJobIdTracker = mock(SaltJobIdTracker.class);
    whenNew(SaltJobIdTracker.class).withAnyArguments().thenReturn(saltJobIdTracker);
    saltOrchestrator.init(parallelOrchestratorComponentRunner, exitCriteria);
    SaltConfig saltConfig = new SaltConfig();
    saltOrchestrator.runService(Collections.singletonList(gatewayConfig), targets, saltConfig, exitCriteriaModel);
    // verify pillar save
    verifyNew(OrchestratorBootstrapRunner.class, times(1)).withArguments(eq(pillarSave), eq(exitCriteria), eq(exitCriteriaModel), any(), anyInt(), anyInt());
    // verify ambari server role
    verifyNew(GrainAddRunner.class, times(1)).withArguments(eq(Sets.newHashSet(gatewayConfig.getPrivateAddress())), eq(targets), eq("ambari_server_install"));
    // verify ambari server role
    verifyNew(GrainAddRunner.class, times(1)).withArguments(eq(Sets.newHashSet(gatewayConfig.getPrivateAddress())), eq(targets), eq("ambari_server"));
    // verify ambari agent role
    Set<String> allNodes = targets.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
    verifyNew(GrainAddRunner.class, times(1)).withArguments(eq(allNodes), eq(targets), eq("ambari_agent_install"));
    // verify ambari agent role
    allNodes = targets.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
    verifyNew(GrainAddRunner.class, times(1)).withArguments(eq(allNodes), eq(targets), eq("ambari_agent"));
    // verify two role command (amabari server, ambari agent)
    verifyNew(SaltCommandTracker.class, times(4)).withArguments(eq(saltConnector), eq(addRemoveGrainRunner));
    // verify two OrchestratorBootstrapRunner call with rolechecker command tracker
    verifyNew(OrchestratorBootstrapRunner.class, times(4)).withArguments(eq(roleCheckerSaltCommandTracker), eq(exitCriteria), eq(exitCriteriaModel), any(), anyInt(), anyInt());
    // verify syncgrains command
    verifyNew(SyncGrainsRunner.class, times(1)).withArguments(eq(allNodes), eq(targets));
    verifyNew(SaltCommandTracker.class, times(1)).withArguments(eq(saltConnector), eq(syncGrainsRunner));
    verifyNew(OrchestratorBootstrapRunner.class, times(1)).withArguments(eq(syncGrainsCheckerSaltCommandTracker), eq(exitCriteria), eq(exitCriteriaModel), any(), anyInt(), anyInt());
    // verify run new service
    verifyNew(HighStateRunner.class, atLeastOnce()).withArguments(eq(allNodes), eq(targets));
    verifyNew(SaltJobIdTracker.class, atLeastOnce()).withArguments(eq(saltConnector), eq(highStateRunner), eq(true));
}

Example 3 with SyncGrainsRunner

use of com.sequenceiq.cloudbreak.orchestrator.salt.poller.checker.SyncGrainsRunner in project cloudbreak by hortonworks.

the class SaltOrchestrator method upgradeAmbari.

@SuppressFBWarnings("REC_CATCH_EXCEPTION")
@Override
public void upgradeAmbari(GatewayConfig gatewayConfig, Set<String> target, Set<Node> allNodes, SaltConfig pillarConfig, ExitCriteriaModel exitCriteriaModel) throws CloudbreakOrchestratorException {
    try (SaltConnector sc = new SaltConnector(gatewayConfig, restDebug)) {
        for (Entry<String, SaltPillarProperties> propertiesEntry : pillarConfig.getServicePillarConfig().entrySet()) {
            OrchestratorBootstrap pillarSave = new PillarSave(sc, Sets.newHashSet(gatewayConfig.getPrivateAddress()), propertiesEntry.getValue());
            Callable<Boolean> saltPillarRunner = runner(pillarSave, exitCriteria, exitCriteriaModel);
            Future<Boolean> saltPillarRunnerFuture = parallelOrchestratorComponentRunner.submit(saltPillarRunner);
            saltPillarRunnerFuture.get();
        }
        // add 'ambari_upgrade' role to all nodes
        Set<String> targets = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        runSaltCommand(sc, new GrainAddRunner(targets, allNodes, "roles", "ambari_upgrade", CompoundType.IP), exitCriteriaModel);
        Set<String> all = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        runSaltCommand(sc, new SyncGrainsRunner(all, allNodes), exitCriteriaModel);
        runNewService(sc, new HighStateRunner(all, allNodes), exitCriteriaModel, maxRetryRecipe, true);
        // remove 'ambari_upgrade' role from all nodes
        targets = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        runSaltCommand(sc, new GrainRemoveRunner(targets, allNodes, "roles", "ambari_upgrade", CompoundType.IP), exitCriteriaModel);
    } catch (Exception e) {
        LOGGER.error("Error occurred during ambari upgrade", e);
        throw new CloudbreakOrchestratorFailedException(e);
    }
}

Example 4 with SyncGrainsRunner

use of com.sequenceiq.cloudbreak.orchestrator.salt.poller.checker.SyncGrainsRunner in project cloudbreak by hortonworks.

the class SaltOrchestrator method runService.

@SuppressFBWarnings("REC_CATCH_EXCEPTION")
@Override
public void runService(List<GatewayConfig> allGateway, Set<Node> allNodes, SaltConfig saltConfig, ExitCriteriaModel exitModel) throws CloudbreakOrchestratorException {
    LOGGER.info("Run Services on nodes: {}", allNodes);
    GatewayConfig primaryGateway = getPrimaryGatewayConfig(allGateway);
    Set<String> gatewayTargets = getGatewayPrivateIps(allGateway);
    String ambariServerAddress = primaryGateway.getPrivateAddress();
    try (SaltConnector sc = new SaltConnector(primaryGateway, restDebug)) {
        OrchestratorBootstrap hostSave = new PillarSave(sc, gatewayTargets, allNodes);
        Callable<Boolean> saltPillarRunner = runner(hostSave, exitCriteria, exitModel);
        Future<Boolean> saltPillarRunnerFuture = parallelOrchestratorComponentRunner.submit(saltPillarRunner);
        saltPillarRunnerFuture.get();
        for (Entry<String, SaltPillarProperties> propertiesEntry : saltConfig.getServicePillarConfig().entrySet()) {
            OrchestratorBootstrap pillarSave = new PillarSave(sc, gatewayTargets, propertiesEntry.getValue());
            saltPillarRunner = runner(pillarSave, exitCriteria, exitModel);
            saltPillarRunnerFuture = parallelOrchestratorComponentRunner.submit(saltPillarRunner);
            saltPillarRunnerFuture.get();
        }
        Set<String> server = Sets.newHashSet(ambariServerAddress);
        Set<String> all = allNodes.stream().map(Node::getPrivateIp).collect(Collectors.toSet());
        // knox
        if (primaryGateway.getKnoxGatewayEnabled()) {
            runSaltCommand(sc, new GrainAddRunner(gatewayTargets, allNodes, "gateway"), exitModel);
        }
        setPostgreRoleIfNeeded(allNodes, saltConfig, exitModel, sc, server);
        // ambari server
        runSaltCommand(sc, new GrainAddRunner(server, allNodes, "ambari_server_install"), exitModel);
        runSaltCommand(sc, new GrainAddRunner(server, allNodes, "ambari_server"), exitModel);
        // ambari server standby
        Set<String> standbyServers = gatewayTargets.stream().filter(ip -> !server.contains(ip)).collect(Collectors.toSet());
        if (!standbyServers.isEmpty()) {
            runSaltCommand(sc, new GrainAddRunner(standbyServers, allNodes, "ambari_server_install"), exitModel);
            runSaltCommand(sc, new GrainAddRunner(standbyServers, allNodes, "ambari_server_standby"), exitModel);
        }
        // ambari agent
        runSaltCommand(sc, new GrainAddRunner(all, allNodes, "ambari_agent_install"), exitModel);
        runSaltCommand(sc, new GrainAddRunner(all, allNodes, "ambari_agent"), exitModel);
        // kerberos
        if (saltConfig.getServicePillarConfig().containsKey("kerberos")) {
            runSaltCommand(sc, new GrainAddRunner(server, allNodes, "kerberos_server_master"), exitModel);
            if (!standbyServers.isEmpty()) {
                runSaltCommand(sc, new GrainAddRunner(standbyServers, allNodes, "kerberos_server_slave"), exitModel);
            }
        }
        // smartsense
        if (configureSmartSense) {
            runSaltCommand(sc, new GrainAddRunner(gatewayTargets, allNodes, "smartsense"), exitModel);
            runSaltCommand(sc, new GrainAddRunner(all, allNodes, "smartsense_agent_update"), exitModel);
        }
        uploadGrains(allNodes, saltConfig.getGrainsProperties(), exitModel, sc);
        runSaltCommand(sc, new SyncGrainsRunner(all, allNodes), exitModel);
        runSaltCommand(sc, new MineUpdateRunner(gatewayTargets, allNodes), exitModel);
        runNewService(sc, new HighStateRunner(all, allNodes), exitModel);
    } catch (Exception e) {
        LOGGER.error("Error occurred during ambari bootstrap", e);
        if (e instanceof ExecutionException && e.getCause() instanceof CloudbreakOrchestratorFailedException) {
            throw (CloudbreakOrchestratorFailedException) e.getCause();
        }
        throw new CloudbreakOrchestratorFailedException(e);
    }
    LOGGER.info("Run services on nodes finished: {}", allNodes);
}