/**
* 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.Collections;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
import javax.persistence.UniqueConstraint;
/**
* The {@link AlertGroupEntity} class manages the logical groupings of
* {@link AlertDefinitionEntity}s in order to easily define what alerts an
* {@link AlertTargetEntity} should be notified on.
*/
@Entity
@Table(
name = "alert_group",
uniqueConstraints = @UniqueConstraint(columnNames = { "cluster_id", "group_name" }))
@TableGenerator(
name = "alert_group_id_generator",
table = "ambari_sequences",
pkColumnName = "sequence_name",
valueColumnName = "sequence_value",
pkColumnValue = "alert_group_id_seq",
initialValue = 0)
@NamedQueries({
@NamedQuery(
name = "AlertGroupEntity.findAll",
query = "SELECT alertGroup FROM AlertGroupEntity alertGroup"),
@NamedQuery(
name = "AlertGroupEntity.findAllInCluster",
query = "SELECT alertGroup FROM AlertGroupEntity alertGroup WHERE alertGroup.clusterId = :clusterId"),
@NamedQuery(
name = "AlertGroupEntity.findByNameInCluster",
query = "SELECT alertGroup FROM AlertGroupEntity alertGroup WHERE alertGroup.groupName = :groupName AND alertGroup.clusterId = :clusterId"),
@NamedQuery(
name = "AlertGroupEntity.findByAssociatedDefinition",
query = "SELECT alertGroup FROM AlertGroupEntity alertGroup WHERE :alertDefinition MEMBER OF alertGroup.alertDefinitions"),
@NamedQuery(
name = "AlertGroupEntity.findServiceDefaultGroup",
query = "SELECT alertGroup FROM AlertGroupEntity alertGroup WHERE alertGroup.clusterId = :clusterId AND alertGroup.serviceName = :serviceName AND alertGroup.isDefault = 1"),
@NamedQuery(
name = "AlertGroupEntity.findByIds",
query = "SELECT alertGroup FROM AlertGroupEntity alertGroup WHERE alertGroup.groupId IN :groupIds") })
public class AlertGroupEntity {
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator = "alert_group_id_generator")
@Column(name = "group_id", nullable = false, updatable = false)
private Long groupId;
@Column(name = "cluster_id", nullable = false)
private Long clusterId;
@Column(name = "group_name", nullable = false, length = 255)
private String groupName;
@Column(name = "is_default", nullable = false)
private Integer isDefault = Integer.valueOf(0);
@Column(name = "service_name", nullable = true, length = 255)
private String serviceName;
/**
* Bi-directional many-to-many association to {@link AlertDefinitionEntity}
*/
@ManyToMany(cascade = CascadeType.MERGE)
@JoinTable(
name = "alert_grouping",
joinColumns = { @JoinColumn(name = "group_id", nullable = false) },
inverseJoinColumns = { @JoinColumn(name = "definition_id", nullable = false) })
private Set<AlertDefinitionEntity> alertDefinitions;
/**
* Unidirectional many-to-many association to {@link AlertTargetEntity}
*/
@ManyToMany(fetch = FetchType.EAGER, cascade = { CascadeType.MERGE, CascadeType.REFRESH })
@JoinTable(
name = "alert_group_target",
joinColumns = { @JoinColumn(name = "group_id", nullable = false) },
inverseJoinColumns = { @JoinColumn(name = "target_id", nullable = false) })
private Set<AlertTargetEntity> alertTargets;
/**
* Gets the unique ID of this grouping of alerts.
*
* @return the ID (never {@code null}).
*/
public Long getGroupId() {
return groupId;
}
/**
* Sets the unique ID of this grouping of alerts.
*
* @param groupId
* the ID (not {@code null}).
*/
public void setGroupId(Long groupId) {
this.groupId = groupId;
}
/**
* Gets the ID of the cluster that this alert group is a part of.
*
* @return the ID (never {@code null}).
*/
public Long getClusterId() {
return clusterId;
}
/**
* Sets the ID of the cluster that this alert group is a part of.
*
* @param clusterId
* the ID of the cluster (not {@code null}).
*/
public void setClusterId(Long clusterId) {
this.clusterId = clusterId;
}
/**
* Gets the name of the grouping of alerts. Group names are unique in a given
* cluster.
*
* @return the group name (never {@code null}).
*/
public String getGroupName() {
return groupName;
}
/**
* Sets the name of this grouping of alerts. Group names are unique in a given
* cluster.
*
* @param groupName
* the name of the group (not {@code null}).
*/
public void setGroupName(String groupName) {
this.groupName = groupName;
}
/**
* Gets whether this is a default group and is mostly read-only. Default
* groups cannot have their alert definition groupings changed. New alert
* definitions are automtaically added to the default group that belongs to
* the service of that definition.
*
* @return {@code true} if this is a default group, {@code false} otherwise.
*/
public boolean isDefault() {
return isDefault == 0 ? false : true;
}
/**
* Sets whether this is a default group and is immutable.
*
* @param isDefault
* {@code true} to make this group immutable.
*/
public void setDefault(boolean isDefault) {
this.isDefault = isDefault == false ? 0 : 1;
}
/**
* Gets the name of the service. This is only applicable when
* {@link #isDefault()} is {@code true}.
*
* @return the service that this is the default group for, or {@code null} if
* this is not a default group.
*/
public String getServiceName() {
return serviceName;
}
/**
* Set the service name. This is only applicable when {@link #isDefault()} is
* {@code true}.
*
* @param serviceName
* the service that this is the default group for, or {@code null} if
* this is not a default group.
*/
public void setServiceName(String serviceName) {
this.serviceName = serviceName;
}
/**
* Gets all of the alert definitions that are a part of this grouping.
*
* @return the alert definitions or an empty set if none (never {@code null).
*/
public Set<AlertDefinitionEntity> getAlertDefinitions() {
if (null == alertDefinitions) {
alertDefinitions = new HashSet<>();
}
return Collections.unmodifiableSet(alertDefinitions);
}
/**
* Set all of the alert definitions that are part of this alert group.
*
* @param alertDefinitions
* the definitions, or {@code null} for none.
*/
public void setAlertDefinitions(Set<AlertDefinitionEntity> alertDefinitions) {
if (null != this.alertDefinitions) {
for (AlertDefinitionEntity definition : this.alertDefinitions) {
definition.removeAlertGroup(this);
}
}
this.alertDefinitions = alertDefinitions;
if (null != alertDefinitions) {
for (AlertDefinitionEntity definition : alertDefinitions) {
definition.addAlertGroup(this);
}
}
}
/**
* Adds the specified definition to the definitions that this group will
* dispatch to.
*
* @param definition
* the definition to add (not {@code null}).
*/
public void addAlertDefinition(AlertDefinitionEntity definition) {
if (null == alertDefinitions) {
alertDefinitions = new HashSet<>();
}
alertDefinitions.add(definition);
definition.addAlertGroup(this);
}
/**
* Removes the specified definition from the definitions that this group will
* dispatch to.
*
* @param definition
* the definition to remove (not {@code null}).
*/
public void removeAlertDefinition(AlertDefinitionEntity definition) {
if (null != alertDefinitions) {
alertDefinitions.remove(definition);
}
definition.removeAlertGroup(this);
}
/**
* Gets an immutable set of the targets that will receive notifications for
* alert definitions in this group.
*
* @return the targets that will be dispatch to for alerts in this group, or
* an empty set if there are none (never {@code null}).
*/
public Set<AlertTargetEntity> getAlertTargets() {
if( null == alertTargets ) {
return Collections.emptySet();
}
return Collections.unmodifiableSet(alertTargets);
}
/**
* Adds the specified target to the targets that this group will dispatch to.
*
* @param alertTarget
* the target to add (not {@code null}).
*/
public void addAlertTarget(AlertTargetEntity alertTarget) {
if (null == alertTargets) {
alertTargets = new HashSet<>();
}
alertTargets.add(alertTarget);
alertTarget.addAlertGroup(this);
}
/**
* Removes the specified target from the targets that this group will dispatch
* to.
*
* @param alertTarget
* the target to remove (not {@code null}).
*/
public void removeAlertTarget(AlertTargetEntity alertTarget) {
if (null != alertTargets) {
alertTargets.remove(alertTarget);
}
alertTarget.removeAlertGroup(this);
}
/**
* Sets all of the targets that will receive notifications for alert
* definitions in this group.
*
* @param alertTargets
* the targets, or {@code null} if there are none.
*/
public void setAlertTargets(Set<AlertTargetEntity> alertTargets) {
// for any existing associations, remove "this" from those associations
if (null != this.alertTargets) {
// make a copy to prevent ConcurrentModificiationExceptions
Set<AlertTargetEntity> copyOfAssociatedTargets = new HashSet<>(this.alertTargets);
for (AlertTargetEntity target : copyOfAssociatedTargets) {
target.removeAlertGroup(this);
}
}
// update all new targets to reflect "this" as an associated group
if (null != alertTargets) {
for (AlertTargetEntity target : alertTargets) {
target.addAlertGroup(this);
}
}
// update reference
this.alertTargets = alertTargets;
}
/**
*
*/
@Override
public boolean equals(Object object) {
if (this == object) {
return true;
}
if (object == null || getClass() != object.getClass()) {
return false;
}
AlertGroupEntity that = (AlertGroupEntity) object;
// use the unique ID if it exists
if( null != groupId ){
return Objects.equals(groupId, that.groupId);
}
return Objects.equals(groupId, that.groupId) &&
Objects.equals(clusterId, that.clusterId) &&
Objects.equals(groupName, that.groupName) &&
Objects.equals(serviceName, that.serviceName);
}
/**
*
*/
@Override
public int hashCode() {
// use the unique ID if it exists
if( null != groupId ){
return groupId.hashCode();
}
return Objects.hash(groupId, clusterId, groupName, serviceName);
}
/**
* {@inheritDoc}
*/
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append(getClass().getSimpleName());
buffer.append("{");
buffer.append("id=").append(groupId);
buffer.append(", name=").append(groupName);
buffer.append(", default=").append(isDefault);
buffer.append("}");
return buffer.toString();
}
}