/**
* 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.entities;
import java.util.Objects;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.Lob;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
import org.apache.ambari.server.state.AlertState;
/**
* The {@link AlertHistoryEntity} class is an instance of an alert state change
* that was received. Instances are only stored in the history if there is a
* state change event. Subsequent alerts that are received for the same state
* update the timestamps in {@link AlertNoticeEntity} but do not receive a new
* {@link AlertHistoryEntity}.
*/
@Entity
@Table(name = "alert_history")
@TableGenerator(name = "alert_history_id_generator", table = "ambari_sequences", pkColumnName = "sequence_name", valueColumnName = "sequence_value", pkColumnValue = "alert_history_id_seq", initialValue = 0)
@NamedQueries({
@NamedQuery(name = "AlertHistoryEntity.findAll", query = "SELECT alertHistory FROM AlertHistoryEntity alertHistory"),
@NamedQuery(name = "AlertHistoryEntity.findAllInCluster", query = "SELECT alertHistory FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId"),
@NamedQuery(name = "AlertHistoryEntity.findAllInClusterWithState", query = "SELECT alertHistory FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId AND alertHistory.alertState IN :alertStates"),
@NamedQuery(name = "AlertHistoryEntity.findAllInClusterBetweenDates", query = "SELECT alertHistory FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId AND alertHistory.alertTimestamp BETWEEN :startDate AND :endDate"),
@NamedQuery(name = "AlertHistoryEntity.findAllInClusterBeforeDate", query = "SELECT alertHistory FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId AND alertHistory.alertTimestamp <= :beforeDate"),
@NamedQuery(name = "AlertHistoryEntity.findAllIdsInClusterBeforeDate", query = "SELECT alertHistory.alertId FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId AND alertHistory.alertTimestamp <= :beforeDate"),
@NamedQuery(name = "AlertHistoryEntity.findAllInClusterAfterDate", query = "SELECT alertHistory FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId AND alertHistory.alertTimestamp >= :afterDate"),
@NamedQuery(name = "AlertHistoryEntity.removeByDefinitionId", query = "DELETE FROM AlertHistoryEntity alertHistory WHERE alertHistory.alertDefinitionId = :definitionId"),
@NamedQuery(name = "AlertHistoryEntity.removeInClusterBeforeDate", query = "DELETE FROM AlertHistoryEntity alertHistory WHERE alertHistory.clusterId = :clusterId AND alertHistory.alertTimestamp <= :beforeDate"),
@NamedQuery(name = "AlertHistoryEntity.findHistoryIdsByDefinitionId", query = "SELECT alertHistory.alertId FROM AlertHistoryEntity alertHistory WHERE alertHistory.alertDefinitionId = :definitionId ORDER BY alertHistory.alertId")
})
public class AlertHistoryEntity {
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "alert_history_id_generator")
@Column(name = "alert_id", nullable = false, updatable = false)
private Long alertId;
@Column(name = "alert_instance", length = 255)
private String alertInstance;
@Column(name = "alert_label", length = 1024)
private String alertLabel;
@Enumerated(value = EnumType.STRING)
@Column(name = "alert_state", nullable = false, length = 255)
private AlertState alertState;
@Lob
@Column(name = "alert_text")
private String alertText;
@Column(name = "alert_timestamp", nullable = false)
private Long alertTimestamp;
@Column(name = "cluster_id", nullable = false)
private Long clusterId;
@Column(name = "component_name", length = 255)
private String componentName;
@Column(name = "host_name", length = 255)
private String hostName;
@Column(name = "service_name", nullable = false, length = 255)
private String serviceName;
/**
* Unidirectional many-to-one association to {@link AlertDefinitionEntity}
*/
@ManyToOne
@JoinColumn(name = "alert_definition_id", nullable = false)
private AlertDefinitionEntity alertDefinition;
@Column(name = "alert_definition_id", nullable = false, insertable = false, updatable = false, length = 10)
private Long alertDefinitionId;
/**
* Constructor.
*/
public AlertHistoryEntity() {
}
/**
* Gets the unique ID for this alert instance.
*
* @return the unique ID (never {@code null}).
*/
public Long getAlertId() {
return alertId;
}
/**
* Sets the unique ID for this alert instance.
*
* @param alertId
* the unique ID (not {@code null}).
*/
public void setAlertId(Long alertId) {
this.alertId = alertId;
}
/**
* Gets the instance identifier, if any, for this alert instance.
*
* @return the instance ID or {@code null} if none.
*/
public String getAlertInstance() {
return alertInstance;
}
/**
* Sets the instance identifier, if any, for this alert instance.
*
* @param alertInstance
* the instance ID or {@code null} if none.
*/
public void setAlertInstance(String alertInstance) {
this.alertInstance = alertInstance;
}
/**
* Gets the label for this alert instance. The label is typically an
* abbreviated form of the alert text.
*
* @return the alert instance label or {@code null} if none.
* @see #getAlertText()
*/
public String getAlertLabel() {
return alertLabel;
}
/**
* Sets the label for this alert instance.
*
* @param alertLabel
* the label or {@code null} if none.
*/
public void setAlertLabel(String alertLabel) {
this.alertLabel = alertLabel;
}
/**
* Gets the state of this alert instance.
*
* @return the alert state (never {@code null}).
*/
public AlertState getAlertState() {
return alertState;
}
/**
* Sets the state of this alert instance.
*
* @param alertState
* the alert state (not {@code null}).
*/
public void setAlertState(AlertState alertState) {
this.alertState = alertState;
}
/**
* Gets the text of the alert instance.
*
* @return the text of the alert instance or {@code null} if none.
*/
public String getAlertText() {
return alertText;
}
/**
* Sets the text of the alert instance.
*
* @param alertText
* the text, or {@code null} if none.
*/
public void setAlertText(String alertText) {
this.alertText = alertText;
}
/**
* Gets the time that the alert instace was received. This will be the value,
* in milliseconds, since the UNIX/Java epoch, represented in UTC time.
*
* @return the time of the alert instance (never {@code null}).
*/
public Long getAlertTimestamp() {
return alertTimestamp;
}
/**
* Sets the time that the alert instace was received. This should be the
* value, in milliseconds, since the UNIX/Java epoch, represented in UTC time.
*
* @param alertTimestamp
* the time of the alert instance (not {@code null}).
*/
public void setAlertTimestamp(Long alertTimestamp) {
this.alertTimestamp = alertTimestamp;
}
/**
* Gets the ID of the cluster that this alert is associated with.
*
* @return the ID of the cluster for the server that this alert is for (never
* {@code null}).
*/
public Long getClusterId() {
return clusterId;
}
/**
* Sets the ID of the cluster that this alert is associated with.
*
* @param clusterId
* the ID of the cluster for the server that this alert is for (never
* {@code null}).
*/
public void setClusterId(Long clusterId) {
this.clusterId = clusterId;
}
/**
* Gets the name of the component, if any, that this alert instance is for.
* Some alerts, such as those that are scoped for the entire service, do not
* have component names.
*
* @return the name of the component, or {@code null} for none.
*/
public String getComponentName() {
return componentName;
}
/**
* Sets the name of the component that this alert instance is associated with.
* Component names are not required if the alert definition is scoped for a
* service. If specified, there is always a 1:1 mapping between alert
* definitions and components.
*
* @param componentName
* the name of the component, or {@code null} if none.
*/
public void setComponentName(String componentName) {
this.componentName = componentName;
}
/**
* Gets the name of the host that the alert is for. Some alerts do not run
* against hosts, such as aggregate alert definitions, so this may be
* {@code null}.
*
* @return the name of the host or {@code null} if none.
*/
public String getHostName() {
return hostName;
}
/**
* Sets the name of the host that the alert is for.
*
* @param hostName
* the name of the host or {@code null} if none.
*/
public void setHostName(String hostName) {
this.hostName = hostName;
}
/**
* Gets the name of the service that the alert is defined for.
*
* @return the name of the service (never {@code null}).
*/
public String getServiceName() {
return serviceName;
}
/**
* Sets the name of the service that the alert is defined for. Every alert
* definition is related to exactly 1 service.
*
* @param serviceName
* the name of the service (not {@code null}).
*/
public void setServiceName(String serviceName) {
this.serviceName = serviceName;
}
/**
* Gets the associated alert definition for this alert instance. The alert
* definition can be used to retrieve global information about an alert such
* as the interval and the name.
*
* @return the alert definition (never {@code null}).
*/
public AlertDefinitionEntity getAlertDefinition() {
return alertDefinition;
}
/**
* Sets the associated alert definition for this alert instance.
*
* @param alertDefinition
* the alert definition (not {@code null}).
*/
public void setAlertDefinition(AlertDefinitionEntity alertDefinition) {
this.alertDefinition = alertDefinition;
alertDefinitionId = alertDefinition.getDefinitionId();
}
/**
* Get parent alert definition id
* @return definition id
*/
public Long getAlertDefinitionId() {
return alertDefinitionId;
}
/**
* Set parent alert definition id
* @param alertDefinitionId definition id
*/
public void setAlertDefinitionId(Long alertDefinitionId) {
this.alertDefinitionId = alertDefinitionId;
}
/**
* Gets the equality to another historical alert entry based on the following criteria:
* <ul>
* <li>{@link #alertId}
* <li>{@link #clusterId}
* <li>{@link #alertInstance}
* <li>{@link #alertLabel}
* <li>{@link #alertState}
* <li>{@link #alertText}
* <li>{@link #alertTimestamp}
* <li>{@link #serviceName}
* <li>{@link #componentName}
* <li>{@link #hostName}
* <li>{@link #alertDefinition}
* </ul>
* <p/>
* However, since we're guaranteed that {@link #alertId} is unique among persisted entities, we
* can return the hashCode based on this value if it is set.
* <p/>
* {@inheritDoc}
*/
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (object == null || getClass() != object.getClass()) {
return false;
}
AlertHistoryEntity that = (AlertHistoryEntity) object;
// use the unique ID if it exists
if( null != alertId ){
return Objects.equals(alertId, that.alertId);
}
return Objects.equals(alertId, that.alertId) &&
Objects.equals(clusterId, that.clusterId) &&
Objects.equals(alertInstance, that.alertInstance) &&
Objects.equals(alertLabel, that.alertLabel) &&
Objects.equals(alertState, that.alertState) &&
Objects.equals(alertText, that.alertText) &&
Objects.equals(alertTimestamp, that.alertTimestamp) &&
Objects.equals(serviceName, that.serviceName) &&
Objects.equals(componentName, that.componentName) &&
Objects.equals(hostName, that.hostName) &&
Objects.equals(alertDefinition, that.alertDefinition);
}
/**
* Gets a hash to uniquely identify this historical alert instance. Since historical entries
* have no real uniqueness properties, we need to rely on a combination of the fields of this
* entity.
* <p/>
* However, since we're guaranteed that {@link #alertId} is unique among persisted entities, we
* can return the hashCode based on this value if it is set.
* <p/>
* {@inheritDoc}
*/
@Override
public int hashCode() {
// use the unique ID if it exists
if( null != alertId ){
return alertId.hashCode();
}
return Objects.hash(alertId, clusterId, alertInstance, alertLabel, alertState, alertText,
alertTimestamp, serviceName, componentName, hostName, alertDefinition);
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append(getClass().getSimpleName());
buffer.append("{");
buffer.append("id=").append(alertId);
buffer.append(", serviceName=").append(serviceName);
buffer.append(", componentName=").append(componentName);
buffer.append(", state=").append(alertState);
buffer.append(", label=").append(alertLabel);
buffer.append("}");
return buffer.toString();
}
public int getAlertDefinitionHash() {
return this.getAlertDefinition().hashCode();
}
}