Java源码示例:com.cloudera.api.swagger.client.ApiClient

示例1
@Test
public void testSetupTelemetry() throws ApiException {
    // GIVEN
    Stack stack = new Stack();
    stack.setType(StackType.WORKLOAD);
    WorkloadAnalytics wa = new WorkloadAnalytics();
    Telemetry telemetry = new Telemetry();
    telemetry.setWorkloadAnalytics(wa);
    ApiConfigList apiConfigList = new ApiConfigList();
    ApiResponse response = new ApiResponse<>(0, null, apiConfigList);
    AltusCredential credential = new AltusCredential("accessKey", "secretKey".toCharArray());
    when(apiClient.execute(any(), any())).thenReturn(response);
    when(clouderaManagerDatabusService.getAltusCredential(stack)).thenReturn(credential);
    when(clouderaManagerApiFactory.getClouderaManagerResourceApi(apiClient)).thenReturn(cmResourceApi);
    when(cmResourceApi.updateConfig(anyString(), any())).thenReturn(apiConfigList);
    // WHEN
    underTest.setupTelemetryRole(stack, apiClient, null, new ApiRoleList(), telemetry);
    // THEN
    verify(externalAccountService, times(1)).createExternalAccount(anyString(), anyString(), anyString(), anyMap(), any(ApiClient.class));
    verify(clouderaManagerDatabusService, times(1)).getAltusCredential(stack);
}
 
示例2
/**
 * Query the ClouderaManager instance associated with the specified client for any service start events in the
 * specified cluster since the specified time.
 *
 * @param client      A ClouderaManager API client.
 * @param clusterName The name of the cluster for which events should be queried.
 * @param since       The ISO8601 timestamp indicating from which time to query.
 *
 * @return A List of ApiEvent objects representing the relevant events since the specified time.
 */
protected List<ApiEvent> queryEvents(final ApiClient client, final String clusterName, final String since) {
  List<ApiEvent> events = new ArrayList<>();

  // Setup the query for events
  String timeFilter =
      (since != null) ? String.format(Locale.ROOT, EVENTS_QUERY_TIMESTAMP_FORMAT, since) : "";

  String queryString = String.format(Locale.ROOT,
                                     EVENTS_QUERY_FORMAT,
                                     clusterName,
                                     timeFilter);

  try {
    ApiEventQueryResult eventsResult = (new EventsResourceApi(client)).readEvents(20, queryString, 0);
    events.addAll(eventsResult.getItems());
  } catch (ApiException e) {
    log.clouderaManagerEventsAPIError(e);
  }

  return events;
}
 
示例3
/**
 * Get the current configuration for the specified service.
 *
 * @param address     The address of the ClouderaManager instance.
 * @param clusterName The name of the cluster.
 * @param service     The name of the service.
 *
 * @return A ServiceConfigurationModel object with the configuration properties associated with the specified
 * service.
 */
protected ServiceConfigurationModel getCurrentServiceConfiguration(final String address,
                                                                   final String clusterName,
                                                                   final String service) {
  ServiceConfigurationModel currentConfig = null;

  log.gettingCurrentClusterConfiguration(service, clusterName, address);

  ApiClient apiClient = getApiClient(configCache.getDiscoveryConfig(address, clusterName));
  ServicesResourceApi api = new ServicesResourceApi(apiClient);
  try {
    ApiServiceConfig svcConfig = api.readServiceConfig(clusterName, service, "full");

    Map<ApiRole, ApiConfigList> roleConfigs = new HashMap<>();
    RolesResourceApi rolesApi = (new RolesResourceApi(apiClient));
    ApiRoleList roles = rolesApi.readRoles(clusterName, service, "", "full");
    for (ApiRole role : roles.getItems()) {
      ApiConfigList config = rolesApi.readRoleConfig(clusterName, role.getName(), service, "full");
      roleConfigs.put(role, config);
    }
    currentConfig = new ServiceConfigurationModel(svcConfig, roleConfigs);
  } catch (ApiException e) {
    log.clouderaManagerConfigurationAPIError(e);
  }
  return currentConfig;
}
 
示例4
@Test
public void testVerifyNodesAreRemovableWithoutRepairAndNotEnoughNode() throws ApiException {
    // GIVEN
    VolumeSetAttributes volumeSetAttributes = new VolumeSetAttributes("az", true, "fstab", List.of(), 50, "vt");
    Stack stack = createTestStack(volumeSetAttributes);
    Cluster cluster = new Cluster();
    stack.setCluster(cluster);
    Set<HostGroup> hostGroups = createTestHostGroups(2, 2);
    cluster.setHostGroups(hostGroups);
    ApiHostTemplateList hostTemplates = createEmptyHostTemplates();
    Mockito.when(clouderaManagerApiFactory.getHostTemplatesResourceApi(Mockito.any(ApiClient.class))).thenReturn(hostTemplatesResourceApi);
    Mockito.when(hostTemplatesResourceApi.readHostTemplates(stack.getName())).thenReturn(hostTemplates);
    Mockito.when(resourceAttributeUtil.getTypedAttributes(stack.getDiskResources().get(0), VolumeSetAttributes.class))
            .thenReturn(Optional.of(volumeSetAttributes));
    // WHEN
    HostGroup firstHostGroup = hostGroups.iterator().next();
    Set<InstanceMetaData> removableInstances = firstHostGroup.getInstanceGroup().getInstanceMetaDataSet();
    InstanceMetaData additionalInstanceMetaData = new InstanceMetaData();
    additionalInstanceMetaData.setInstanceGroup(firstHostGroup.getInstanceGroup());
    removableInstances.add(additionalInstanceMetaData);
    // WHEN
    assertThrows(NotEnoughNodeException.class,
            () -> underTest.verifyNodesAreRemovable(stack, removableInstances, new ApiClient()));
    // THEN the above exception should have thrown
}
 
示例5
private ApiClient getApiClientWithContext(HttpClientConfig clientConfig, Integer port, String userName, String password, String context)
        throws ClouderaManagerClientInitException {
    try {
        ApiClient cmClient = new ApiClient();
        if (clientConfig.isClusterProxyEnabled()) {
            cmClient.setBasePath(clientConfig.getClusterProxyUrl() + "/proxy/" + clientConfig.getClusterCrn() + "/cb-internal" + context);
            cmClient.addDefaultHeader("Proxy-Ignore-Auth", "true");
            cmClient.addDefaultHeader("Proxy-With-Timeout", CLUSTER_PROXY_TIMEOUT.toString());
        } else if (port != null) {
            cmClient.setBasePath("https://" + clientConfig.getApiAddress() + ':' + port + context);
        } else {
            cmClient.setBasePath("https://" + clientConfig.getApiAddress() + context);
        }
        return decorateClient(clientConfig, userName, password, cmClient);
    } catch (Exception e) {
        LOGGER.warn("Couldn't create client", e);
        throw new ClouderaManagerClientInitException("Couldn't create client", e);
    }
}
 
示例6
private ApiClient decorateClient(HttpClientConfig clientConfig, String userName, String password, ApiClient cmClient) throws Exception {
    cmClient.setUsername(userName);
    cmClient.setPassword(password);
    cmClient.setVerifyingSsl(true);

    try {
        if (isCmSslConfigValidClientConfigValid(clientConfig) && !clientConfig.isClusterProxyEnabled()) {
            SSLContext sslContext = SSLContexts.custom()
                    .loadTrustMaterial(KeyStoreUtil.createTrustStore(clientConfig.getServerCert()), null)
                    .loadKeyMaterial(KeyStoreUtil.createKeyStore(clientConfig.getClientCert(), clientConfig.getClientKey()), "consul".toCharArray())
                    .build();
            cmClient.getHttpClient().setSslSocketFactory(sslContext.getSocketFactory());
            cmClient.getHttpClient().setHostnameVerifier(CertificateTrustManager.hostnameVerifier());
        }
        cmClient.getHttpClient().setConnectTimeout(1L, TimeUnit.MINUTES);
        cmClient.getHttpClient().setReadTimeout(1L, TimeUnit.MINUTES);
        cmClient.getHttpClient().setWriteTimeout(1L, TimeUnit.MINUTES);
        return cmClient;
    } catch (Exception e) {
        LOGGER.info("Cannot create SSL context for Cloudera Manager", e);
        throw new ClouderaManagerClientInitException("Couldn't create client", e);
    }
}
 
示例7
@Test
public void testDisableKnoxAutorestartIfCmVersionAtLeast() throws ApiException {
    setUpCMVersion(VERSION_7_1_0);

    ServicesResourceApi serviceResourceApi = mock(ServicesResourceApi.class);
    when(clouderaManagerApiFactory.getServicesResourceApi(any())).thenReturn(serviceResourceApi);

    String knoxName = "knox-e07";
    ApiServiceList apiServiceList = new ApiServiceList()
            .addItemsItem(new ApiService().name("hbase-a63").type("HBASE"))
            .addItemsItem(new ApiService().name(knoxName).type("KNOX"));
    when(serviceResourceApi.readServices(TEST_CLUSTER_NAME, DataView.SUMMARY.name())).thenReturn(apiServiceList);

    underTest.disableKnoxAutorestartIfCmVersionAtLeast(CLOUDERAMANAGER_VERSION_7_1_0, new ApiClient(), TEST_CLUSTER_NAME);

    ArgumentCaptor<ApiServiceConfig> apiServiceConfigArgumentCaptor = ArgumentCaptor.forClass(ApiServiceConfig.class);
    verify(serviceResourceApi, times(1))
            .updateServiceConfig(eq(TEST_CLUSTER_NAME), eq(knoxName), eq(""), apiServiceConfigArgumentCaptor.capture());

    ApiServiceConfig actualBody = apiServiceConfigArgumentCaptor.getValue();
    assertFalse(actualBody.getItems().isEmpty());
    ApiConfig actualApiConfig = actualBody.getItems().get(0);
    assertEquals(ClouderaManagerConfigService.KNOX_AUTORESTART_ON_STOP, actualApiConfig.getName());
    assertEquals(Boolean.FALSE.toString(), actualApiConfig.getValue());
}
 
示例8
public void verifyNodesAreRemovable(Stack stack, Collection<InstanceMetaData> removableInstances, ApiClient client) {
    try {
        HostTemplatesResourceApi hostTemplatesResourceApi = clouderaManagerApiFactory.getHostTemplatesResourceApi(client);
        ApiHostTemplateList hostTemplates = hostTemplatesResourceApi.readHostTemplates(stack.getName());

        for (HostGroup hostGroup : stack.getCluster().getHostGroups()) {
            Set<InstanceMetaData> removableHostsInHostGroup = removableInstances.stream()
                    .filter(instanceMetaData -> instanceMetaData.getInstanceGroup().getGroupName().equals(hostGroup.getName()))
                    .collect(Collectors.toSet());
            if (!removableHostsInHostGroup.isEmpty()) {
                String hostGroupName = hostGroup.getName();
                int replication = hostGroupNodesAreDataNodes(hostTemplates, hostGroupName) ? getReplicationFactor(client, stack.getName()) : 0;
                verifyNodeCount(replication, removableHostsInHostGroup.size(), hostGroup.getInstanceGroup().getRunningInstanceMetaDataSet().size(),
                        0, stack);
            }
        }
    } catch (ApiException ex) {
        throw new CloudbreakServiceException("Could not verify if nodes are removable or not", ex);
    }
}
 
示例9
@Override
public void replaceUserNamePassword(String newUserName, String newPassword) throws CloudbreakException {
    Cluster cluster = stack.getCluster();
    String user = cluster.getCloudbreakAmbariUser();
    String password = cluster.getCloudbreakAmbariPassword();
    try {
        ApiClient client = getClient(stack.getGatewayPort(), user, password, clientConfig);
        UsersResourceApi usersResourceApi = clouderaManagerApiFactory.getUserResourceApi(client);
        ApiUser2List oldUserList = usersResourceApi.readUsers2("SUMMARY");
        Optional<ApiUser2> oldAdminUser = oldUserList.getItems().stream()
                .filter(apiUser2 -> apiUser2.getName().equals(stack.getCluster().getUserName()))
                .findFirst();
        if (oldAdminUser.isPresent()) {
            createNewUser(usersResourceApi, oldAdminUser.get().getAuthRoles(), newUserName, newPassword, oldUserList);
            usersResourceApi.deleteUser2(oldAdminUser.get().getName());
        } else {
            throw new CloudbreakException("Can't find original admin user");
        }
    } catch (ApiException | ClouderaManagerClientInitException e) {
        LOGGER.info("Can't replace original admin user due to: ", e);
        throw new CloudbreakException("Can't replace original admin user due to: " + e.getMessage());
    }
}
 
示例10
@Test
public void testSetCdpEnvironmentWhenCmVersion702() throws ApiException {
    ClouderaManagerResourceApi clouderaManagerResourceApi = mock(ClouderaManagerResourceApi.class);
    when(clouderaManagerApiFactory.getClouderaManagerResourceApi(any())).thenReturn(clouderaManagerResourceApi);
    ApiVersionInfo version702 = new ApiVersionInfo().version(VERSION_7_0_2);
    when(clouderaManagerResourceApi.getVersion()).thenReturn(version702);

    underTest.setCdpEnvironmentIfCmVersionAtLeast(CLOUDERAMANAGER_VERSION_7_0_2, new ApiClient());

    ArgumentCaptor<ApiConfigList> apiConfigListCaptor = ArgumentCaptor.forClass(ApiConfigList.class);
    verify(clouderaManagerResourceApi).updateConfig(eq(""), apiConfigListCaptor.capture());
    List<ApiConfigList> capturedApiConfigList = apiConfigListCaptor.getAllValues();
    assertThat(capturedApiConfigList, hasSize(1));
    assertThat(capturedApiConfigList.get(0).getItems(), hasSize(1));
    ApiConfig apiConfig = capturedApiConfigList.get(0).getItems().get(0);
    assertEquals(apiConfig.getName(), "cdp_environment");
    assertEquals(apiConfig.getValue(), "PUBLIC_CLOUD");
}
 
示例11
@Test
public void testRestartClusterRolesShouldUpdateTheRoles() throws ApiException, CloudbreakException {
    ApiClient apiClient = mock(ApiClient.class);
    Stack stack = createStack();
    ClustersResourceApi clustersResourceApi = mock(ClustersResourceApi.class);
    ClouderaManagerResourceApi clouderaManagerResourceApi = mock(ClouderaManagerResourceApi.class);
    ApiCommand apiCommand = createApiCommand();
    ApiCommandList apiCommandList = createApiCommandList();

    when(clouderaManagerApiFactory.getClouderaManagerResourceApi(apiClient)).thenReturn(clouderaManagerResourceApi);
    when(clouderaManagerResourceApi.listActiveCommands(DataView.SUMMARY.name())).thenReturn(apiCommandList);
    when(clouderaManagerApiFactory.getClustersResourceApi(apiClient)).thenReturn(clustersResourceApi);
    when(clustersResourceApi.refresh(CLUSTER_NAME)).thenReturn(apiCommand);
    when(clouderaManagerPollingServiceProvider.startPollingCmConfigurationRefresh(stack, apiClient, COMMAND_ID)).thenReturn(PollingResult.SUCCESS);

    underTest.refreshClusterRoles(apiClient, stack);

    verify(clouderaManagerPollingServiceProvider).startPollingCmConfigurationRefresh(stack, apiClient, COMMAND_ID);
    verify(clustersResourceApi).refresh(CLUSTER_NAME);
    verify(clouderaManagerPollingServiceProvider).startPollingCmConfigurationRefresh(stack, apiClient, COMMAND_ID);
}
 
示例12
@Override
public void updateUserNamePassword(String newPassword) throws CloudbreakException {
    Cluster cluster = stack.getCluster();
    String cmUser = cluster.getCloudbreakAmbariUser();
    String password = cluster.getCloudbreakAmbariPassword();
    try {
        ApiClient client = getClient(stack.getGatewayPort(), cmUser, password, clientConfig);
        UsersResourceApi usersResourceApi = clouderaManagerApiFactory.getUserResourceApi(client);
        ApiUser2List oldUserList = usersResourceApi.readUsers2("SUMMARY");
        Optional<ApiUser2> oldAdminUser = oldUserList.getItems().stream()
                .filter(apiUser2 -> apiUser2.getName().equals(stack.getCluster().getUserName()))
                .findFirst();
        if (oldAdminUser.isPresent()) {
            ApiUser2 user = oldAdminUser.get();
            user.setPassword(newPassword);
            usersResourceApi.updateUser2(user.getName(), user);
        } else {
            throw new CloudbreakException("Can't find admin user");
        }
    } catch (ApiException | ClouderaManagerClientInitException e) {
        LOGGER.info("Can't replace admin password due to: ", e);
        throw new CloudbreakException("Can't replace admin password due to: " + e.getMessage());
    }
}
 
示例13
public void deleteCredentials(HttpClientConfig clientConfig, Stack stack) {
    Cluster cluster = stack.getCluster();
    String user = cluster.getCloudbreakAmbariUser();
    String password = cluster.getCloudbreakAmbariPassword();
    try {
        ApiClient client = clouderaManagerApiClientProvider.getClient(stack.getGatewayPort(), user, password, clientConfig);
        clouderaManagerConfigService.disableKnoxAutorestartIfCmVersionAtLeast(CLOUDERAMANAGER_VERSION_7_1_0, client, stack.getName());

        ClouderaManagerModificationService modificationService = applicationContext.getBean(ClouderaManagerModificationService.class, stack, clientConfig);
        modificationService.stopCluster(false);

        ClouderaManagerClusterDecomissionService decomissionService = applicationContext.getBean(ClouderaManagerClusterDecomissionService.class,
                stack, clientConfig);
        decomissionService.removeManagementServices();

        ClouderaManagerResourceApi apiInstance = clouderaManagerApiFactory.getClouderaManagerResourceApi(client);
        ApiCommand command = apiInstance.deleteCredentialsCommand("all");
        clouderaManagerPollingServiceProvider.startPollingCmKerberosJob(stack, client, command.getId());
    } catch (ApiException | CloudbreakException | ClouderaManagerClientInitException e) {
        LOGGER.info("Failed to remove Kerberos credentials", e);
        throw new ClouderaManagerOperationFailedException("Failed to remove Kerberos credentials", e);
    }
}
 
示例14
public int getTotalHosts(Cluster cluster) {
    try {
        Long clusterId = cluster.getId();
        LOGGER.debug("Checking number of total hosts for cluster {}.", clusterId);
        HttpClientConfig httpClientConfig = tlsHttpClientConfigurationService.buildTLSClientConfig(cluster.getStackCrn(),
                cluster.getClusterManager().getHost(), cluster.getTunnel());
        ClusterManager cm = cluster.getClusterManager();
        String user = secretService.get(cm.getUser());
        String pass = secretService.get(cm.getPass());
        ApiClient client = clouderaManagerApiClientProvider.getClient(Integer.valueOf(cm.getPort()), user, pass, httpClientConfig);
        HostsResourceApi hostsResourceApi = clouderaManagerApiFactory.getHostsResourceApi(client);
        return hostsResourceApi.readHosts(null, null, DataView.SUMMARY.name()).getItems().size();
    } catch (Exception e) {
        LOGGER.info("Failed to retrieve number of total hosts. Original message: {}", e.getMessage());
        throw new ClusterManagerException("Failed to retrieve number of total hosts", e);
    }
}
 
示例15
@Test
public void testCollectDownscaleCandidatesWhenEveryHostHasHostnameButNotEnoughNodesToDownscale() throws ApiException {
    // GIVEN
    VolumeSetAttributes volumeSetAttributes = new VolumeSetAttributes("az", false, "fstab", List.of(), 50, "vt");
    Stack stack = createTestStack(volumeSetAttributes);
    Cluster cluster = new Cluster();
    stack.setCluster(cluster);
    Set<HostGroup> hostGroups = createTestHostGroups(1, 6);
    cluster.setHostGroups(hostGroups);
    HostGroup downscaledHostGroup = hostGroups.iterator().next();
    ClustersResourceApi clustersResourceApi = mock(ClustersResourceApi.class);
    when(clouderaManagerApiFactory.getClustersResourceApi(any(ApiClient.class))).thenReturn(clustersResourceApi);
    HostsResourceApi hostsResourceApi = mock(HostsResourceApi.class);
    when(clouderaManagerApiFactory.getHostsResourceApi(any(ApiClient.class))).thenReturn(hostsResourceApi);
    HostTemplatesResourceApi hostTemplatesResourceApi = mock(HostTemplatesResourceApi.class);
    when(clouderaManagerApiFactory.getHostTemplatesResourceApi(any(ApiClient.class))).thenReturn(hostTemplatesResourceApi);
    ApiHostTemplateList hostTemplates = createEmptyHostTemplates();
    Mockito.when(hostTemplatesResourceApi.readHostTemplates(stack.getName())).thenReturn(hostTemplates);
    assertThrows(NotEnoughNodeException.class, () -> underTest.collectDownscaleCandidates(mock(ApiClient.class), stack, downscaledHostGroup, -8, 0,
            downscaledHostGroup.getInstanceGroup().getAllInstanceMetaData()));
}
 
示例16
/**
 * Sets up the management services using the given Cloudera Manager apiClient.
 *
 * @param stack      the stack
 * @param apiClient     the CM API apiClient
 * @param cmHostRef  reference to the CM host
 * @param rdsConfigs the set of all database configs
 * @param telemetry  telemetry (logging/workload/billing etc.) details
 * @param sdxContextName sdx name holder
 * @param sdxStackCrn sdx stack crn holder
 * @param proxyConfig ccm proxy configuration holder
 * @throws ApiException if there's a problem setting up management services
 */
public void setupMgmtServices(Stack stack, ApiClient apiClient, ApiHostRef cmHostRef,
        Set<RDSConfig> rdsConfigs, Telemetry telemetry, String sdxContextName, String sdxStackCrn,
        ProxyConfig proxyConfig)
        throws ApiException {
    LOGGER.debug("Setting up Cloudera Management Services.");
    licenseService.validateClouderaManagerLicense(stack.getCreator());
    MgmtServiceResourceApi mgmtServiceResourceApi = clouderaManagerApiFactory.getMgmtServiceResourceApi(apiClient);
    MgmtRolesResourceApi mgmtRolesResourceApi = clouderaManagerApiFactory.getMgmtRolesResourceApi(apiClient);

    ApiService mgmtService = new ApiService();
    mgmtService.setName(MGMT_SERVICE);
    mgmtService.setType(MGMT_SERVICE);

    setupCMS(mgmtServiceResourceApi, mgmtService);

    ApiRoleList mgmtRoles = new ApiRoleList();
    List<String> roleTypes = mgmtServiceResourceApi.listRoleTypes().getItems();
    for (String roleType : roleTypes) {
        if (!BLACKLISTED_ROLE_TYPES.contains(roleType)) {
            LOGGER.debug("Role type {} is not on black list. Adding it to management roles for host {}.", roleType, cmHostRef.getHostname());
            ApiRole apiRole = new ApiRole();
            apiRole.setName(roleType);
            apiRole.setType(roleType);
            apiRole.setHostRef(cmHostRef);
            mgmtRoles.addItemsItem(apiRole);
        }
    }
    cmConfigService.setConfigs(stack, mgmtRoles);
    telemetryService.setupTelemetryRole(stack, apiClient, cmHostRef, mgmtRoles, telemetry);
    createMgmtRoles(mgmtRolesResourceApi, mgmtRoles);
    telemetryService.updateTelemetryConfigs(stack, apiClient, telemetry, sdxContextName, sdxStackCrn, proxyConfig);
    createMgmtDatabases(apiClient, rdsConfigs);
    waitForGenerateCredentialsToFinish(stack, apiClient);
    setUpAutoConfiguration(mgmtServiceResourceApi);
}
 
示例17
public ApiClient getDefaultClient(Integer gatewayPort, HttpClientConfig clientConfig, String apiVersion) throws ClouderaManagerClientInitException {
    ApiClient client = getClouderaManagerClient(clientConfig, gatewayPort, "admin", "admin", apiVersion);
    if (clientConfig.isClusterProxyEnabled()) {
        client.addDefaultHeader("Proxy-Ignore-Auth", "true");
    }
    return client;
}
 
示例18
@Override
protected boolean doStatusCheck(ClouderaManagerPollerObject pollerObject, CommandsResourceApi commandsResourceApi) throws ApiException {
    ApiClient apiClient = pollerObject.getApiClient();
    Stack stack = pollerObject.getStack();
    List<ClouderaManagerProduct> clouderaManagerProducts = getClouderaManagerProductsFromStack(stack);
    ApiParcelList parcels = getClouderaManagerParcels(apiClient, stack.getName());
    List<ApiParcel> notActivated = getNotActivatedOrMissingParcels(clouderaManagerProducts, parcels);
    if (notActivated.isEmpty()) {
        LOGGER.debug("Parcels are activated.");
        return true;
    } else {
        LOGGER.debug("Some parcels are not yet activated: [{}].", getJoinedParcelStages(notActivated));
        return false;
    }
}
 
示例19
void refreshClusterRoles(ApiClient client, Stack stack) throws ApiException, CloudbreakException {
    LOGGER.debug("Cluster role refresh has been started.");
    waitForGenerateCredentialsToFinish(stack, client);
    ClustersResourceApi clustersResourceApi = clouderaManagerApiFactory.getClustersResourceApi(client);
    ApiCommand refreshCommand = clustersResourceApi.refresh(stack.getCluster().getName());
    pollingRefresh(refreshCommand, client, stack);
    LOGGER.debug("Cluster role refresh finished successfully.");
}
 
示例20
private PollingResult pollCommandWithTimeListener(Stack stack, ApiClient apiClient, BigDecimal commandId, int numAttempts,
        AbstractClouderaManagerCommandCheckerTask<ClouderaManagerPollerObject> listenerTask) {
    ClouderaManagerPollerObject clouderaManagerPollerObject = new ClouderaManagerPollerObject(stack, apiClient, commandId);
    return clouderaManagerCommandPollerObjectPollingService.pollWithTimeoutSingleFailure(
            listenerTask,
            clouderaManagerPollerObject,
            POLL_INTERVAL,
            numAttempts);
}
 
示例21
void startManagementServices(Stack stack, ApiClient apiClient) throws ApiException {
    MgmtServiceResourceApi mgmtServiceResourceApi = getMgmtServiceResourceApi(apiClient);
    ApiService mgmtService = getMgmtService(mgmtServiceResourceApi);
    Optional<ApiCommand> startCommand = Optional.empty();
    ApiServiceState serviceState = mgmtService.getServiceState();
    if (serviceState != ApiServiceState.STARTED && serviceState != ApiServiceState.STARTING) {
        startCommand = Optional.of(mgmtServiceResourceApi.startCommand());
    }
    startCommand.ifPresent(command -> startPolling(stack, apiClient, command));
}
 
示例22
private PollingResult pollCommandWithAttemptListener(Stack stack, ApiClient apiClient, BigDecimal commandId, int numAttempts,
        AbstractClouderaManagerCommandCheckerTask<ClouderaManagerPollerObject> listenerTask) {
    ClouderaManagerPollerObject clouderaManagerPollerObject = new ClouderaManagerPollerObject(stack, apiClient, commandId);
    return clouderaManagerCommandPollerObjectPollingService.pollWithAttemptSingleFailure(
            listenerTask,
            clouderaManagerPollerObject,
            POLL_INTERVAL,
            numAttempts);
}
 
示例23
public Map<String, ApiConfig> getRoleConfigPropertiesFromCM(Cluster cluster, String serviceName,
        String roleGroupRef, Set roleConfigPropertyNames) {
    LOGGER.debug("Retrieving roleConfigProperties for cluster '{}', service '{}', roleGroupRef '{}'",
            cluster.getStackCrn(), serviceName, roleGroupRef);

    HttpClientConfig httpClientConfig = tlsHttpClientConfigurationService.buildTLSClientConfig(cluster.getStackCrn(),
            cluster.getClusterManager().getHost(), cluster.getTunnel());
    ClusterManager cm = cluster.getClusterManager();
    String user = secretService.get(cm.getUser());
    String pass = secretService.get(cm.getPass());

    Map<String, ApiConfig> roleConfigProperties = requestLogging.logResponseTime(() -> {
        try {
            ApiClient client = clouderaManagerApiClientProvider.getClient(Integer.valueOf(cm.getPort()), user, pass, httpClientConfig);
            RoleConfigGroupsResourceApi roleConfigGroupsResourceApi = clouderaManagerApiFactory.getRoleConfigGroupsResourceApi(client);

            return roleConfigGroupsResourceApi
                    .readConfig(cluster.getStackName(), roleGroupRef, serviceName, DataView.FULL.name())
                    .getItems().stream()
                    .filter(apiConfig -> roleConfigPropertyNames.contains(apiConfig.getName()))
                    .collect(Collectors.toMap(ApiConfig::getName, apiConfig -> apiConfig));
        } catch (Exception ex) {
            throw new RuntimeException(String.format("Error retrieving roleConfigProperties for cluster '%s', service '%s', roleGroupRef '%s'",
                    cluster.getStackCrn(), serviceName, roleGroupRef), ex);
        }
    }, String.format("getRoleConfigPropertiesFromCM for cluster crn '%s'", cluster.getStackCrn()));

    LOGGER.debug("Retrieved roleConfigPropertyValues for cluster '{}', service '{}', roleGroupRef '{}', roleConfigProperties '{}",
            cluster.getStackCrn(), serviceName, roleGroupRef,
            roleConfigProperties.values().stream().map(apiConfig -> String.format("ApiConfig Name '%s, Value '%s', Default '%s",
                    apiConfig.getName(), apiConfig.getValue(), apiConfig.getDefault())).collect(Collectors.toSet()));
    return roleConfigProperties;
}
 
示例24
@Test
public void testSetCdpEnvironmentWhenCmVersion701() throws ApiException {
    ClouderaManagerResourceApi clouderaManagerResourceApi = mock(ClouderaManagerResourceApi.class);
    when(clouderaManagerApiFactory.getClouderaManagerResourceApi(any())).thenReturn(clouderaManagerResourceApi);
    ApiVersionInfo version701 = new ApiVersionInfo().version(VERSION_7_0_1);
    when(clouderaManagerResourceApi.getVersion()).thenReturn(version701);

    underTest.setCdpEnvironmentIfCmVersionAtLeast(CLOUDERAMANAGER_VERSION_7_0_2, new ApiClient());

    verify(clouderaManagerResourceApi, never()).updateConfig(any(), any());
}
 
示例25
@Override
public void waitForHosts(Set<InstanceMetaData> hostsInCluster) throws ClusterClientInitException {
    Cluster cluster = stack.getCluster();
    String user = cluster.getCloudbreakAmbariUser();
    String password = cluster.getCloudbreakAmbariPassword();
    ApiClient client;
    try {
        client = clouderaManagerApiClientProvider.getClient(stack.getGatewayPort(), user, password, clientConfig);
    } catch (ClouderaManagerClientInitException e) {
        throw new ClusterClientInitException(e);
    }
    clouderaManagerPollingServiceProvider.startPollingCmHostStatus(stack, client);
}
 
示例26
@Override
public void setupMonitoringUser() throws CloudbreakException {
    Cluster cluster = stack.getCluster();
    String user = cluster.getCloudbreakAmbariUser();
    String password = cluster.getCloudbreakAmbariPassword();
    try {
        ApiClient client = getClient(stack.getGatewayPort(), user, password, clientConfig);
        UsersResourceApi usersResourceApi = clouderaManagerApiFactory.getUserResourceApi(client);
        String monitoringUser = cluster.getCloudbreakClusterManagerMonitoringUser();
        String monitoringPassword = cluster.getCloudbreakClusterManagerMonitoringPassword();
        ApiUser2List userList = usersResourceApi.readUsers2("SUMMARY");
        Optional<ApiUser2> mUser = userList.getItems().stream()
                .filter(apiUser2 -> apiUser2.getName().equals(monitoringUser))
                .findFirst();
        if (mUser.isPresent()) {
            LOGGER.info("Monitoring user '{}' already exists. Skipping user generation", monitoringUser);
        } else {
            List<ApiAuthRoleRef> authRoles = new ArrayList<>();
            ApiAuthRoleRef apiAuthRoleRef = new ApiAuthRoleRef();
            apiAuthRoleRef.setName("ROLE_ADMIN");
            authRoles.add(apiAuthRoleRef);
            createNewUser(usersResourceApi, authRoles, monitoringUser, monitoringPassword, userList);
        }
    } catch (ApiException | ClouderaManagerClientInitException e) {
        throw new CloudbreakException("Can't replace admin password due to: " + e.getMessage());
    }
}
 
示例27
public void enableKnoxAutorestartIfCmVersionAtLeast(Versioned versionAtLeast, ApiClient client, String clusterName) {
    try {
        ClouderaManagerResourceApi resourceApiInstance = clouderaManagerApiFactory.getClouderaManagerResourceApi(client);
        if (isVersionAtLeast(versionAtLeast, resourceApiInstance)) {
            modifyKnoxAutorestart(client, clusterName, true);
        }
    } catch (ApiException e) {
        LOGGER.debug("Failed to initialize CM client.", e);
    }
}
 
示例28
@Test
public void testInitApiClientShouldCreateTheApiClient() throws ClusterClientInitException, ClouderaManagerClientInitException {
    ReflectionTestUtils.setField(underTest, "client", null);
    ApiClient client = Mockito.mock(ApiClient.class);
    when(clouderaManagerApiClientProvider.getClient(GATEWAY_PORT, USER, PASSWORD, clientConfig)).thenReturn(client);

    underTest.initApiClient();

    assertEquals(client, ReflectionTestUtils.getField(underTest, "client"));
    verify(clouderaManagerApiClientProvider).getClient(GATEWAY_PORT, USER, PASSWORD, clientConfig);
}
 
示例29
@Override
public void waitForServer() throws CloudbreakException, ClusterClientInitException {
    ApiClient client = createApiClient();
    PollingResult pollingResult = clouderaManagerPollingServiceProvider.startPollingCmStartup(stack, client);
    if (isSuccess(pollingResult)) {
        LOGGER.debug("Cloudera Manager server has successfully started! Polling result: {}", pollingResult);
    } else if (isExited(pollingResult)) {
        throw new CancellationException("Polling of Cloudera Manager server start has been cancelled.");
    } else {
        LOGGER.debug("Could not start Cloudera Manager. polling result: {}", pollingResult);
        throw new CloudbreakException(String.format("Could not start Cloudera Manager. polling result: '%s'", pollingResult));
    }
}
 
示例30
public ApiClient getClient(Integer gatewayPort, String user, String password, HttpClientConfig clientConfig) throws ClouderaManagerClientInitException {
    if (StringUtils.isNoneBlank(user, password)) {
        return clouderaManagerApiClientProvider.getClouderaManagerClient(clientConfig,
                gatewayPort, user, password, ClouderaManagerApiClientProvider.API_V_31);
    } else {
        return getDefaultClient(gatewayPort, clientConfig);
    }
}