@BeforeClass
  public static void setup() throws AmbariException {
    injector = Guice.createInjector(new InMemoryDefaultTestModule());
    injector.getInstance(GuiceJpaInitializer.class);
    configHelper = injector.getInstance(ConfigHelper.class);
    configFactory = injector.getInstance(ConfigFactory.class);

    clusters = injector.getInstance(Clusters.class);
    clusters.addHost(HOST1);
    clusters.getHost(HOST1).persist();
    clusters.addCluster(CLUSTER1);

    Cluster cluster1 = clusters.getCluster(CLUSTER1);

    SERVICE_SITE_CLUSTER = new HashMap<String, String>();
    SERVICE_SITE_CLUSTER.put(SERVICE_SITE_NAME1, SERVICE_SITE_VAL1);
    SERVICE_SITE_CLUSTER.put(SERVICE_SITE_NAME2, SERVICE_SITE_VAL2);
    SERVICE_SITE_CLUSTER.put(SERVICE_SITE_NAME3, SERVICE_SITE_VAL3);
    SERVICE_SITE_CLUSTER.put(SERVICE_SITE_NAME4, SERVICE_SITE_VAL4);

    SERVICE_SITE_SERVICE = new HashMap<String, String>();
    SERVICE_SITE_SERVICE.put(SERVICE_SITE_NAME1, SERVICE_SITE_VAL1_S);
    SERVICE_SITE_SERVICE.put(SERVICE_SITE_NAME2, SERVICE_SITE_VAL2_S);
    SERVICE_SITE_SERVICE.put(SERVICE_SITE_NAME5, SERVICE_SITE_VAL5_S);

    SERVICE_SITE_HOST = new HashMap<String, String>();
    SERVICE_SITE_HOST.put(SERVICE_SITE_NAME2, SERVICE_SITE_VAL2_H);
    SERVICE_SITE_HOST.put(SERVICE_SITE_NAME6, SERVICE_SITE_VAL6_H);

    GLOBAL_CLUSTER = new HashMap<String, String>();
    GLOBAL_CLUSTER.put(GLOBAL_NAME1, GLOBAL_CLUSTER_VAL1);
    GLOBAL_CLUSTER.put(GLOBAL_NAME2, GLOBAL_CLUSTER_VAL2);

    CONFIG_ATTRIBUTES = new HashMap<String, Map<String, String>>();

    // Cluster level global config
    Config globalConfig =
        configFactory.createNew(cluster1, GLOBAL_CONFIG, GLOBAL_CLUSTER, CONFIG_ATTRIBUTES);
    globalConfig.setTag(CLUSTER_VERSION_TAG);
    cluster1.addConfig(globalConfig);

    // Cluster level service config
    Config serviceSiteConfigCluster =
        configFactory.createNew(
            cluster1, SERVICE_SITE_CONFIG, SERVICE_SITE_CLUSTER, CONFIG_ATTRIBUTES);
    serviceSiteConfigCluster.setTag(CLUSTER_VERSION_TAG);
    cluster1.addConfig(serviceSiteConfigCluster);

    // Service level service config
    Config serviceSiteConfigService =
        configFactory.createNew(
            cluster1, SERVICE_SITE_CONFIG, SERVICE_SITE_SERVICE, CONFIG_ATTRIBUTES);
    serviceSiteConfigService.setTag(SERVICE_VERSION_TAG);
    cluster1.addConfig(serviceSiteConfigService);

    // Host level service config
    Config serviceSiteConfigHost =
        configFactory.createNew(
            cluster1, SERVICE_SITE_CONFIG, SERVICE_SITE_HOST, CONFIG_ATTRIBUTES);
    serviceSiteConfigHost.setTag(HOST_VERSION_TAG);
    cluster1.addConfig(serviceSiteConfigHost);

    ActionDBAccessor db = injector.getInstance(ActionDBAccessorImpl.class);

    createTask(db, 1, 1, HOST1, CLUSTER1);
  }
  protected void deleteHosts(Set<HostRequest> requests) throws AmbariException {

    AmbariManagementController controller = getManagementController();
    Clusters clusters = controller.getClusters();

    List<HostRequest> okToRemove = new ArrayList<HostRequest>();

    for (HostRequest hostRequest : requests) {
      String hostName = hostRequest.getHostname();
      if (null == hostName) {
        continue;
      }

      Set<String> clusterNamesForHost = new HashSet<String>();
      if (null != hostRequest.getClusterName()) {
        clusterNamesForHost.add(hostRequest.getClusterName());
      } else {
        Set<Cluster> clustersForHost = clusters.getClustersForHost(hostRequest.getHostname());
        if (null != clustersForHost) {
          for (Cluster c : clustersForHost) {
            clusterNamesForHost.add(c.getClusterName());
          }
        }
      }

      for (String clusterName : clusterNamesForHost) {
        Cluster cluster = clusters.getCluster(clusterName);

        List<ServiceComponentHost> list = cluster.getServiceComponentHosts(hostName);

        if (!list.isEmpty()) {

          List<String> componentsToRemove = new ArrayList<String>();
          for (ServiceComponentHost sch : list) {
            Service s = cluster.getService(sch.getServiceName());
            ServiceComponent sc = s.getServiceComponent(sch.getServiceComponentName());

            // Masters and Slaves must be deleted first. Clients are ok.
            if (!sc.isClientComponent()) {
              componentsToRemove.add(sch.getServiceComponentName());
            }
          }

          if (!componentsToRemove.isEmpty()) {
            StringBuilder reason =
                new StringBuilder("Cannot remove host ")
                    .append(hostName)
                    .append(" from ")
                    .append(hostRequest.getClusterName())
                    .append(
                        ".  The following roles exist, and these components must be stopped if running, and then deleted: ");

            reason.append(StringUtils.join(componentsToRemove, ", "));

            throw new AmbariException(reason.toString());
          }
        }
      }
      okToRemove.add(hostRequest);
    }

    for (HostRequest hostRequest : okToRemove) {
      // Assume the user also wants to delete it entirely, including all clusters.
      clusters.deleteHost(hostRequest.getHostname());

      if (null != hostRequest.getClusterName()) {
        clusters.getCluster(hostRequest.getClusterName()).recalculateAllClusterVersionStates();
      }
    }
  }
  protected static Set<HostResponse> getHosts(
      AmbariManagementController controller, HostRequest request) throws AmbariException {

    // TODO/FIXME host can only belong to a single cluster so get host directly from Cluster
    // TODO/FIXME what is the requirement for filtering on host attributes?

    List<Host> hosts;
    Set<HostResponse> response = new HashSet<HostResponse>();
    Cluster cluster = null;

    Clusters clusters = controller.getClusters();

    String clusterName = request.getClusterName();
    String hostName = request.getHostname();

    if (clusterName != null) {
      // validate that cluster exists, throws exception if it doesn't.
      try {
        cluster = clusters.getCluster(clusterName);
      } catch (ObjectNotFoundException e) {
        throw new ParentObjectNotFoundException("Parent Cluster resource doesn't exist", e);
      }
    }

    if (hostName == null) {
      hosts = clusters.getHosts();
    } else {
      hosts = new ArrayList<Host>();
      try {
        hosts.add(clusters.getHost(request.getHostname()));
      } catch (HostNotFoundException e) {
        // add cluster name
        throw new HostNotFoundException(clusterName, hostName);
      }
    }

    for (Host h : hosts) {
      if (clusterName != null) {
        if (clusters.getClustersForHost(h.getHostName()).contains(cluster)) {
          HostResponse r = h.convertToResponse();

          r.setClusterName(clusterName);
          r.setDesiredHostConfigs(h.getDesiredHostConfigs(cluster));
          r.setMaintenanceState(h.getMaintenanceState(cluster.getClusterId()));

          response.add(r);
        } else if (hostName != null) {
          throw new HostNotFoundException(clusterName, hostName);
        }
      } else {
        HostResponse r = h.convertToResponse();

        Set<Cluster> clustersForHost = clusters.getClustersForHost(h.getHostName());
        // todo: host can only belong to a single cluster
        if (clustersForHost != null && clustersForHost.size() != 0) {
          r.setClusterName(clustersForHost.iterator().next().getClusterName());
        }
        response.add(r);
      }
    }
    return response;
  }
  protected synchronized void updateHosts(Set<HostRequest> requests) throws AmbariException {

    if (requests.isEmpty()) {
      LOG.warn("Received an empty requests set");
      return;
    }

    AmbariManagementController controller = getManagementController();
    Clusters clusters = controller.getClusters();

    for (HostRequest request : requests) {
      if (request.getHostname() == null || request.getHostname().isEmpty()) {
        throw new IllegalArgumentException("Invalid arguments, hostname should be provided");
      }
    }

    for (HostRequest request : requests) {
      if (LOG.isDebugEnabled()) {
        LOG.debug(
            "Received an updateHost request"
                + ", hostname="
                + request.getHostname()
                + ", request="
                + request);
      }

      Host host = clusters.getHost(request.getHostname());

      String clusterName = request.getClusterName();

      try {
        // The below method call throws an exception when trying to create a duplicate mapping in
        // the clusterhostmapping
        // table. This is done to detect duplicates during host create. In order to be robust,
        // handle these gracefully.
        clusters.mapHostToCluster(request.getHostname(), clusterName);
      } catch (DuplicateResourceException e) {
        // do nothing
      }

      if (null != request.getHostAttributes()) {
        host.setHostAttributes(request.getHostAttributes());
      }

      String rackInfo = host.getRackInfo();
      String requestRackInfo = request.getRackInfo();
      boolean rackChange = requestRackInfo != null && !requestRackInfo.equals(rackInfo);

      if (rackChange) {
        host.setRackInfo(requestRackInfo);
      }

      if (null != request.getPublicHostName()) {
        host.setPublicHostName(request.getPublicHostName());
      }

      if (null != clusterName && null != request.getMaintenanceState()) {
        Cluster c = clusters.getCluster(clusterName);
        MaintenanceState newState = MaintenanceState.valueOf(request.getMaintenanceState());
        MaintenanceState oldState = host.getMaintenanceState(c.getClusterId());
        if (!newState.equals(oldState)) {
          if (newState.equals(MaintenanceState.IMPLIED_FROM_HOST)
              || newState.equals(MaintenanceState.IMPLIED_FROM_SERVICE)) {
            throw new IllegalArgumentException(
                "Invalid arguments, can only set "
                    + "maintenance state to one of "
                    + EnumSet.of(MaintenanceState.OFF, MaintenanceState.ON));
          } else {
            host.setMaintenanceState(c.getClusterId(), newState);
          }
        }
      }

      // Create configurations
      if (null != clusterName && null != request.getDesiredConfigs()) {
        Cluster c = clusters.getCluster(clusterName);

        if (clusters.getHostsForCluster(clusterName).containsKey(host.getHostName())) {

          for (ConfigurationRequest cr : request.getDesiredConfigs()) {

            if (null != cr.getProperties() && cr.getProperties().size() > 0) {
              LOG.info(
                  MessageFormat.format(
                      "Applying configuration with tag ''{0}'' to host ''{1}'' in cluster ''{2}''",
                      cr.getVersionTag(), request.getHostname(), clusterName));

              cr.setClusterName(c.getClusterName());
              controller.createConfiguration(cr);
            }

            Config baseConfig = c.getConfig(cr.getType(), cr.getVersionTag());
            if (null != baseConfig) {
              String authName = controller.getAuthName();
              DesiredConfig oldConfig = host.getDesiredConfigs(c.getClusterId()).get(cr.getType());

              if (host.addDesiredConfig(c.getClusterId(), cr.isSelected(), authName, baseConfig)) {
                Logger logger = LoggerFactory.getLogger("configchange");
                logger.info(
                    "cluster '"
                        + c.getClusterName()
                        + "', "
                        + "host '"
                        + host.getHostName()
                        + "' "
                        + "changed by: '"
                        + authName
                        + "'; "
                        + "type='"
                        + baseConfig.getType()
                        + "' "
                        + "version='"
                        + baseConfig.getVersion()
                        + "'"
                        + "tag='"
                        + baseConfig.getTag()
                        + "'"
                        + (null == oldConfig ? "" : ", from='" + oldConfig.getTag() + "'"));
              }
            }
          }
        }
      }

      if (clusterName != null && !clusterName.isEmpty()) {
        clusters.getCluster(clusterName).recalculateAllClusterVersionStates();
        if (rackChange) {
          controller.registerRackChange(clusterName);
        }
      }

      // todo: if attempt was made to update a property other than those
      // todo: that are allowed above, should throw exception
    }
  }
Esempio n. 5
0
  @Transactional
  public void populateData(Cluster cluster) throws Exception {
    // remove any definitions and start over
    List<AlertDefinitionEntity> definitions = m_definitionDao.findAll();
    for (AlertDefinitionEntity definition : definitions) {
      m_definitionDao.remove(definition);
    }

    AlertTargetEntity administrators = new AlertTargetEntity();
    administrators.setDescription("The Administrators");
    administrators.setNotificationType("EMAIL");
    administrators.setTargetName("Administrators");
    m_dispatchDAO.create(administrators);

    AlertTargetEntity operators = new AlertTargetEntity();
    operators.setDescription("The Operators");
    operators.setNotificationType("EMAIL");
    operators.setTargetName("Operators");
    m_dispatchDAO.create(operators);

    // create some definitions
    AlertDefinitionEntity namenode = new AlertDefinitionEntity();
    namenode.setDefinitionName("NAMENODE");
    namenode.setServiceName("HDFS");
    namenode.setComponentName("NAMENODE");
    namenode.setClusterId(cluster.getClusterId());
    namenode.setHash(UUID.randomUUID().toString());
    namenode.setScheduleInterval(Integer.valueOf(60));
    namenode.setScope(Scope.ANY);
    namenode.setSource("{\"type\" : \"SCRIPT\"}");
    namenode.setSourceType(SourceType.SCRIPT);
    m_definitionDao.create(namenode);

    AlertDefinitionEntity datanode = new AlertDefinitionEntity();
    datanode.setDefinitionName("DATANODE");
    datanode.setServiceName("HDFS");
    datanode.setComponentName("DATANODE");
    datanode.setClusterId(cluster.getClusterId());
    datanode.setHash(UUID.randomUUID().toString());
    datanode.setScheduleInterval(Integer.valueOf(60));
    datanode.setScope(Scope.HOST);
    datanode.setSource("{\"type\" : \"SCRIPT\"}");
    datanode.setSourceType(SourceType.SCRIPT);
    m_definitionDao.create(datanode);

    AlertDefinitionEntity aggregate = new AlertDefinitionEntity();
    aggregate.setDefinitionName("YARN_AGGREGATE");
    aggregate.setServiceName("YARN");
    aggregate.setComponentName(null);
    aggregate.setClusterId(cluster.getClusterId());
    aggregate.setHash(UUID.randomUUID().toString());
    aggregate.setScheduleInterval(Integer.valueOf(60));
    aggregate.setScope(Scope.SERVICE);
    aggregate.setSource("{\"type\" : \"SCRIPT\"}");
    aggregate.setSourceType(SourceType.SCRIPT);
    m_definitionDao.create(aggregate);

    // create some history
    AlertHistoryEntity nnHistory = new AlertHistoryEntity();
    nnHistory.setAlertState(AlertState.OK);
    nnHistory.setServiceName(namenode.getServiceName());
    nnHistory.setComponentName(namenode.getComponentName());
    nnHistory.setClusterId(cluster.getClusterId());
    nnHistory.setAlertDefinition(namenode);
    nnHistory.setAlertLabel(namenode.getDefinitionName());
    nnHistory.setAlertText(namenode.getDefinitionName());
    nnHistory.setAlertTimestamp(calendar.getTimeInMillis());
    nnHistory.setHostName(HOSTNAME);
    m_alertsDAO.create(nnHistory);

    AlertHistoryEntity dnHistory = new AlertHistoryEntity();
    dnHistory.setAlertState(AlertState.WARNING);
    dnHistory.setServiceName(datanode.getServiceName());
    dnHistory.setComponentName(datanode.getComponentName());
    dnHistory.setClusterId(cluster.getClusterId());
    dnHistory.setAlertDefinition(datanode);
    dnHistory.setAlertLabel(datanode.getDefinitionName());
    dnHistory.setAlertText(datanode.getDefinitionName());
    dnHistory.setAlertTimestamp(calendar.getTimeInMillis());
    dnHistory.setHostName(HOSTNAME);
    m_alertsDAO.create(dnHistory);

    AlertHistoryEntity aggregateHistory = new AlertHistoryEntity();
    aggregateHistory.setAlertState(AlertState.CRITICAL);
    aggregateHistory.setServiceName(aggregate.getServiceName());
    aggregateHistory.setComponentName(aggregate.getComponentName());
    aggregateHistory.setClusterId(cluster.getClusterId());
    aggregateHistory.setAlertDefinition(aggregate);
    aggregateHistory.setAlertLabel(aggregate.getDefinitionName());
    aggregateHistory.setAlertText(aggregate.getDefinitionName());
    aggregateHistory.setAlertTimestamp(calendar.getTimeInMillis());
    m_alertsDAO.create(aggregateHistory);

    AlertNoticeEntity nnPendingNotice = new AlertNoticeEntity();
    nnPendingNotice.setAlertHistory(nnHistory);
    nnPendingNotice.setAlertTarget(administrators);
    nnPendingNotice.setNotifyState(NotificationState.PENDING);
    nnPendingNotice.setUuid(UUID.randomUUID().toString());
    m_dispatchDAO.create(nnPendingNotice);

    AlertNoticeEntity dnDeliveredNotice = new AlertNoticeEntity();
    dnDeliveredNotice.setAlertHistory(dnHistory);
    dnDeliveredNotice.setAlertTarget(administrators);
    dnDeliveredNotice.setNotifyState(NotificationState.FAILED);
    dnDeliveredNotice.setUuid(UUID.randomUUID().toString());
    m_dispatchDAO.create(dnDeliveredNotice);

    AlertNoticeEntity aggregateFailedNotice = new AlertNoticeEntity();
    aggregateFailedNotice.setAlertHistory(aggregateHistory);
    aggregateFailedNotice.setAlertTarget(operators);
    aggregateFailedNotice.setNotifyState(NotificationState.FAILED);
    aggregateFailedNotice.setUuid(UUID.randomUUID().toString());
    m_dispatchDAO.create(aggregateFailedNotice);

    List<AlertHistoryEntity> histories = m_alertsDAO.findAll();
    assertEquals(3, histories.size());
  }