hadoop TimelineEntity 源码

haddop TimelineEntity 代码

文件路径：/hadoop-yarn-project/hadoop-yarn/hadoop-yarn-api/src/main/java/org/apache/hadoop/yarn/api/records/timeline/TimelineEntity.java

/**
 * 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.hadoop.yarn.api.records.timeline;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

import org.apache.hadoop.classification.InterfaceAudience.Private;
import org.apache.hadoop.classification.InterfaceAudience.Public;
import org.apache.hadoop.classification.InterfaceStability.Evolving;
import org.apache.hadoop.yarn.util.TimelineServiceHelper;

/**
 * <p>
 * The class that contains the the meta information of some conceptual entity
 * and its related events. The entity can be an application, an application
 * attempt, a container or whatever the user-defined object.
 * </p>
 * 
 * <p>
 * Primary filters will be used to index the entities in
 * <code>TimelineStore</code>, such that users should carefully choose the
 * information they want to store as the primary filters. The remaining can be
 * stored as other information.
 * </p>
 */
@XmlRootElement(name = "entity")
@XmlAccessorType(XmlAccessType.NONE)
@Public
@Evolving
public class TimelineEntity implements Comparable<TimelineEntity> {

  private String entityType;
  private String entityId;
  private Long startTime;
  private List<TimelineEvent> events = new ArrayList<TimelineEvent>();
  private HashMap<String, Set<String>> relatedEntities =
      new HashMap<String, Set<String>>();
  private HashMap<String, Set<Object>> primaryFilters =
      new HashMap<String, Set<Object>>();
  private HashMap<String, Object> otherInfo =
      new HashMap<String, Object>();
  private String domainId;

  public TimelineEntity() {

  }

  /**
   * Get the entity type
   * 
   * @return the entity type
   */
  @XmlElement(name = "entitytype")
  public String getEntityType() {
    return entityType;
  }

  /**
   * Set the entity type
   * 
   * @param entityType
   *          the entity type
   */
  public void setEntityType(String entityType) {
    this.entityType = entityType;
  }

  /**
   * Get the entity Id
   * 
   * @return the entity Id
   */
  @XmlElement(name = "entity")
  public String getEntityId() {
    return entityId;
  }

  /**
   * Set the entity Id
   * 
   * @param entityId
   *          the entity Id
   */
  public void setEntityId(String entityId) {
    this.entityId = entityId;
  }

  /**
   * Get the start time of the entity
   * 
   * @return the start time of the entity
   */
  @XmlElement(name = "starttime")
  public Long getStartTime() {
    return startTime;
  }

  /**
   * Set the start time of the entity
   * 
   * @param startTime
   *          the start time of the entity
   */
  public void setStartTime(Long startTime) {
    this.startTime = startTime;
  }

  /**
   * Get a list of events related to the entity
   * 
   * @return a list of events related to the entity
   */
  @XmlElement(name = "events")
  public List<TimelineEvent> getEvents() {
    return events;
  }

  /**
   * Add a single event related to the entity to the existing event list
   * 
   * @param event
   *          a single event related to the entity
   */
  public void addEvent(TimelineEvent event) {
    events.add(event);
  }

  /**
   * Add a list of events related to the entity to the existing event list
   * 
   * @param events
   *          a list of events related to the entity
   */
  public void addEvents(List<TimelineEvent> events) {
    this.events.addAll(events);
  }

  /**
   * Set the event list to the given list of events related to the entity
   * 
   * @param events
   *          events a list of events related to the entity
   */
  public void setEvents(List<TimelineEvent> events) {
    this.events = events;
  }

  /**
   * Get the related entities
   * 
   * @return the related entities
   */
  public Map<String, Set<String>> getRelatedEntities() {
    return relatedEntities;
  }

  // Required by JAXB
  @Private
  @XmlElement(name = "relatedentities")
  public HashMap<String, Set<String>> getRelatedEntitiesJAXB() {
    return relatedEntities;
  }

  /**
   * Add an entity to the existing related entity map
   * 
   * @param entityType
   *          the entity type
   * @param entityId
   *          the entity Id
   */
  public void addRelatedEntity(String entityType, String entityId) {
    Set<String> thisRelatedEntity = relatedEntities.get(entityType);
    if (thisRelatedEntity == null) {
      thisRelatedEntity = new HashSet<String>();
      relatedEntities.put(entityType, thisRelatedEntity);
    }
    thisRelatedEntity.add(entityId);
  }

  /**
   * Add a map of related entities to the existing related entity map
   * 
   * @param relatedEntities
   *          a map of related entities
   */
  public void addRelatedEntities(Map<String, Set<String>> relatedEntities) {
    for (Entry<String, Set<String>> relatedEntity : relatedEntities.entrySet()) {
      Set<String> thisRelatedEntity =
          this.relatedEntities.get(relatedEntity.getKey());
      if (thisRelatedEntity == null) {
        this.relatedEntities.put(
            relatedEntity.getKey(), relatedEntity.getValue());
      } else {
        thisRelatedEntity.addAll(relatedEntity.getValue());
      }
    }
  }

  /**
   * Set the related entity map to the given map of related entities
   * 
   * @param relatedEntities
   *          a map of related entities
   */
  public void setRelatedEntities(
      Map<String, Set<String>> relatedEntities) {
    this.relatedEntities = TimelineServiceHelper.mapCastToHashMap(
        relatedEntities);
  }

  /**
   * Get the primary filters
   * 
   * @return the primary filters
   */
  public Map<String, Set<Object>> getPrimaryFilters() {
    return primaryFilters;
  }

  // Required by JAXB
  @Private
  @XmlElement(name = "primaryfilters")
  public HashMap<String, Set<Object>> getPrimaryFiltersJAXB() {
    return primaryFilters;
  }

  /**
   * Add a single piece of primary filter to the existing primary filter map
   * 
   * @param key
   *          the primary filter key
   * @param value
   *          the primary filter value
   */
  public void addPrimaryFilter(String key, Object value) {
    Set<Object> thisPrimaryFilter = primaryFilters.get(key);
    if (thisPrimaryFilter == null) {
      thisPrimaryFilter = new HashSet<Object>();
      primaryFilters.put(key, thisPrimaryFilter);
    }
    thisPrimaryFilter.add(value);
  }

  /**
   * Add a map of primary filters to the existing primary filter map
   * 
   * @param primaryFilters
   *          a map of primary filters
   */
  public void addPrimaryFilters(Map<String, Set<Object>> primaryFilters) {
    for (Entry<String, Set<Object>> primaryFilter : primaryFilters.entrySet()) {
      Set<Object> thisPrimaryFilter =
          this.primaryFilters.get(primaryFilter.getKey());
      if (thisPrimaryFilter == null) {
        this.primaryFilters.put(
            primaryFilter.getKey(), primaryFilter.getValue());
      } else {
        thisPrimaryFilter.addAll(primaryFilter.getValue());
      }
    }
  }

  /**
   * Set the primary filter map to the given map of primary filters
   * 
   * @param primaryFilters
   *          a map of primary filters
   */
  public void setPrimaryFilters(Map<String, Set<Object>> primaryFilters) {
    this.primaryFilters =
        TimelineServiceHelper.mapCastToHashMap(primaryFilters);
  }

  /**
   * Get the other information of the entity
   * 
   * @return the other information of the entity
   */
  public Map<String, Object> getOtherInfo() {
    return otherInfo;
  }

  // Required by JAXB
  @Private
  @XmlElement(name = "otherinfo")
  public HashMap<String, Object> getOtherInfoJAXB() {
    return otherInfo;
  }

  /**
   * Add one piece of other information of the entity to the existing other info
   * map
   * 
   * @param key
   *          the other information key
   * @param value
   *          the other information value
   */
  public void addOtherInfo(String key, Object value) {
    this.otherInfo.put(key, value);
  }

  /**
   * Add a map of other information of the entity to the existing other info map
   * 
   * @param otherInfo
   *          a map of other information
   */
  public void addOtherInfo(Map<String, Object> otherInfo) {
    this.otherInfo.putAll(otherInfo);
  }

  /**
   * Set the other info map to the given map of other information
   * 
   * @param otherInfo
   *          a map of other information
   */
  public void setOtherInfo(Map<String, Object> otherInfo) {
    this.otherInfo = TimelineServiceHelper.mapCastToHashMap(otherInfo);
  }

  /**
   * Get the ID of the domain that the entity is to be put
   * 
   * @return the domain ID
   */
  @XmlElement(name = "domain")
  public String getDomainId() {
    return domainId;
  }

  /**
   * Set the ID of the domain that the entity is to be put
   * 
   * @param domainId
   *          the name space ID
   */
  public void setDomainId(String domainId) {
    this.domainId = domainId;
  }

  @Override
  public int hashCode() {
    // generated by eclipse
    final int prime = 31;
    int result = 1;
    result = prime * result + ((entityId == null) ? 0 : entityId.hashCode());
    result =
        prime * result + ((entityType == null) ? 0 : entityType.hashCode());
    result = prime * result + ((events == null) ? 0 : events.hashCode());
    result = prime * result + ((otherInfo == null) ? 0 : otherInfo.hashCode());
    result =
        prime * result
            + ((primaryFilters == null) ? 0 : primaryFilters.hashCode());
    result =
        prime * result
            + ((relatedEntities == null) ? 0 : relatedEntities.hashCode());
    result = prime * result + ((startTime == null) ? 0 : startTime.hashCode());
    return result;
  }

  @Override
  public boolean equals(Object obj) {
    // generated by eclipse
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    TimelineEntity other = (TimelineEntity) obj;
    if (entityId == null) {
      if (other.entityId != null)
        return false;
    } else if (!entityId.equals(other.entityId))
      return false;
    if (entityType == null) {
      if (other.entityType != null)
        return false;
    } else if (!entityType.equals(other.entityType))
      return false;
    if (events == null) {
      if (other.events != null)
        return false;
    } else if (!events.equals(other.events))
      return false;
    if (otherInfo == null) {
      if (other.otherInfo != null)
        return false;
    } else if (!otherInfo.equals(other.otherInfo))
      return false;
    if (primaryFilters == null) {
      if (other.primaryFilters != null)
        return false;
    } else if (!primaryFilters.equals(other.primaryFilters))
      return false;
    if (relatedEntities == null) {
      if (other.relatedEntities != null)
        return false;
    } else if (!relatedEntities.equals(other.relatedEntities))
      return false;
    if (startTime == null) {
      if (other.startTime != null)
        return false;
    } else if (!startTime.equals(other.startTime))
      return false;
    return true;
  }

  @Override
  public int compareTo(TimelineEntity other) {
    int comparison = entityType.compareTo(other.entityType);
    if (comparison == 0) {
      long thisStartTime =
          startTime == null ? Long.MIN_VALUE : startTime;
      long otherStartTime =
          other.startTime == null ? Long.MIN_VALUE : other.startTime;
      if (thisStartTime > otherStartTime) {
        return -1;
      } else if (thisStartTime < otherStartTime) {
        return 1;
      } else {
        return entityId.compareTo(other.entityId);
      }
    } else {
      return comparison;
    }
  }

}

相关信息

hadoop 源码目录

相关文章

hadoop TimelineAbout 源码

hadoop TimelineDelegationTokenResponse 源码

hadoop TimelineDomain 源码

hadoop TimelineDomains 源码

hadoop TimelineEntities 源码

hadoop TimelineEntityGroupId 源码

hadoop TimelineEvent 源码

hadoop TimelineEvents 源码

hadoop TimelineHealth 源码

hadoop TimelinePutResponse 源码