/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ambari.server.orm;
import static org.junit.Assert.assertEquals;
import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;
import java.util.UUID;
import org.apache.ambari.server.orm.dao.AlertDefinitionDAO;
import org.apache.ambari.server.orm.dao.AlertDispatchDAO;
import org.apache.ambari.server.orm.dao.AlertsDAO;
import org.apache.ambari.server.orm.entities.AlertDefinitionEntity;
import org.apache.ambari.server.orm.entities.AlertHistoryEntity;
import org.apache.ambari.server.orm.entities.AlertNoticeEntity;
import org.apache.ambari.server.orm.entities.AlertTargetEntity;
import org.apache.ambari.server.state.AlertState;
import org.apache.ambari.server.state.Cluster;
import org.apache.ambari.server.state.NotificationState;
import org.apache.ambari.server.state.alert.Scope;
import org.apache.ambari.server.state.alert.SourceType;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import com.google.inject.persist.Transactional;
@Singleton
public class AlertDaoHelper {
private final static String HOSTNAME = "c6401.ambari.apache.org";
private final static Calendar calendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
@Inject
private AlertDefinitionDAO m_definitionDao;
@Inject
private AlertDispatchDAO m_dispatchDAO;
@Inject
private AlertsDAO m_alertsDAO;
/**
*
*/
@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());
}
}