001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018
019 package org.apache.hadoop.yarn.api.records.timeline;
020
021 import java.util.ArrayList;
022 import java.util.HashMap;
023 import java.util.HashSet;
024 import java.util.List;
025 import java.util.Map;
026 import java.util.Map.Entry;
027 import java.util.Set;
028
029 import javax.xml.bind.annotation.XmlAccessType;
030 import javax.xml.bind.annotation.XmlAccessorType;
031 import javax.xml.bind.annotation.XmlElement;
032 import javax.xml.bind.annotation.XmlRootElement;
033
034 import org.apache.hadoop.classification.InterfaceAudience.Public;
035 import org.apache.hadoop.classification.InterfaceStability.Unstable;
036
037 /**
038 * <p>
039 * The class that contains the the meta information of some conceptual entity
040 * and its related events. The entity can be an application, an application
041 * attempt, a container or whatever the user-defined object.
042 * </p>
043 *
044 * <p>
045 * Primary filters will be used to index the entities in
046 * <code>TimelineStore</code>, such that users should carefully choose the
047 * information they want to store as the primary filters. The remaining can be
048 * stored as other information.
049 * </p>
050 */
051 @XmlRootElement(name = "entity")
052 @XmlAccessorType(XmlAccessType.NONE)
053 @Public
054 @Unstable
055 public class TimelineEntity implements Comparable<TimelineEntity> {
056
057 private String entityType;
058 private String entityId;
059 private Long startTime;
060 private List<TimelineEvent> events = new ArrayList<TimelineEvent>();
061 private Map<String, Set<String>> relatedEntities =
062 new HashMap<String, Set<String>>();
063 private Map<String, Set<Object>> primaryFilters =
064 new HashMap<String, Set<Object>>();
065 private Map<String, Object> otherInfo =
066 new HashMap<String, Object>();
067
068 public TimelineEntity() {
069
070 }
071
072 /**
073 * Get the entity type
074 *
075 * @return the entity type
076 */
077 @XmlElement(name = "entitytype")
078 public String getEntityType() {
079 return entityType;
080 }
081
082 /**
083 * Set the entity type
084 *
085 * @param entityType
086 * the entity type
087 */
088 public void setEntityType(String entityType) {
089 this.entityType = entityType;
090 }
091
092 /**
093 * Get the entity Id
094 *
095 * @return the entity Id
096 */
097 @XmlElement(name = "entity")
098 public String getEntityId() {
099 return entityId;
100 }
101
102 /**
103 * Set the entity Id
104 *
105 * @param entityId
106 * the entity Id
107 */
108 public void setEntityId(String entityId) {
109 this.entityId = entityId;
110 }
111
112 /**
113 * Get the start time of the entity
114 *
115 * @return the start time of the entity
116 */
117 @XmlElement(name = "starttime")
118 public Long getStartTime() {
119 return startTime;
120 }
121
122 /**
123 * Set the start time of the entity
124 *
125 * @param startTime
126 * the start time of the entity
127 */
128 public void setStartTime(Long startTime) {
129 this.startTime = startTime;
130 }
131
132 /**
133 * Get a list of events related to the entity
134 *
135 * @return a list of events related to the entity
136 */
137 @XmlElement(name = "events")
138 public List<TimelineEvent> getEvents() {
139 return events;
140 }
141
142 /**
143 * Add a single event related to the entity to the existing event list
144 *
145 * @param event
146 * a single event related to the entity
147 */
148 public void addEvent(TimelineEvent event) {
149 events.add(event);
150 }
151
152 /**
153 * Add a list of events related to the entity to the existing event list
154 *
155 * @param events
156 * a list of events related to the entity
157 */
158 public void addEvents(List<TimelineEvent> events) {
159 this.events.addAll(events);
160 }
161
162 /**
163 * Set the event list to the given list of events related to the entity
164 *
165 * @param events
166 * events a list of events related to the entity
167 */
168 public void setEvents(List<TimelineEvent> events) {
169 this.events = events;
170 }
171
172 /**
173 * Get the related entities
174 *
175 * @return the related entities
176 */
177 @XmlElement(name = "relatedentities")
178 public Map<String, Set<String>> getRelatedEntities() {
179 return relatedEntities;
180 }
181
182 /**
183 * Add an entity to the existing related entity map
184 *
185 * @param entityType
186 * the entity type
187 * @param entityId
188 * the entity Id
189 */
190 public void addRelatedEntity(String entityType, String entityId) {
191 Set<String> thisRelatedEntity = relatedEntities.get(entityType);
192 if (thisRelatedEntity == null) {
193 thisRelatedEntity = new HashSet<String>();
194 relatedEntities.put(entityType, thisRelatedEntity);
195 }
196 thisRelatedEntity.add(entityId);
197 }
198
199 /**
200 * Add a map of related entities to the existing related entity map
201 *
202 * @param relatedEntities
203 * a map of related entities
204 */
205 public void addRelatedEntities(Map<String, Set<String>> relatedEntities) {
206 for (Entry<String, Set<String>> relatedEntity : relatedEntities.entrySet()) {
207 Set<String> thisRelatedEntity =
208 this.relatedEntities.get(relatedEntity.getKey());
209 if (thisRelatedEntity == null) {
210 this.relatedEntities.put(
211 relatedEntity.getKey(), relatedEntity.getValue());
212 } else {
213 thisRelatedEntity.addAll(relatedEntity.getValue());
214 }
215 }
216 }
217
218 /**
219 * Set the related entity map to the given map of related entities
220 *
221 * @param relatedEntities
222 * a map of related entities
223 */
224 public void setRelatedEntities(
225 Map<String, Set<String>> relatedEntities) {
226 this.relatedEntities = relatedEntities;
227 }
228
229 /**
230 * Get the primary filters
231 *
232 * @return the primary filters
233 */
234 @XmlElement(name = "primaryfilters")
235 public Map<String, Set<Object>> getPrimaryFilters() {
236 return primaryFilters;
237 }
238
239 /**
240 * Add a single piece of primary filter to the existing primary filter map
241 *
242 * @param key
243 * the primary filter key
244 * @param value
245 * the primary filter value
246 */
247 public void addPrimaryFilter(String key, Object value) {
248 Set<Object> thisPrimaryFilter = primaryFilters.get(key);
249 if (thisPrimaryFilter == null) {
250 thisPrimaryFilter = new HashSet<Object>();
251 primaryFilters.put(key, thisPrimaryFilter);
252 }
253 thisPrimaryFilter.add(value);
254 }
255
256 /**
257 * Add a map of primary filters to the existing primary filter map
258 *
259 * @param primaryFilters
260 * a map of primary filters
261 */
262 public void addPrimaryFilters(Map<String, Set<Object>> primaryFilters) {
263 for (Entry<String, Set<Object>> primaryFilter : primaryFilters.entrySet()) {
264 Set<Object> thisPrimaryFilter =
265 this.primaryFilters.get(primaryFilter.getKey());
266 if (thisPrimaryFilter == null) {
267 this.primaryFilters.put(
268 primaryFilter.getKey(), primaryFilter.getValue());
269 } else {
270 thisPrimaryFilter.addAll(primaryFilter.getValue());
271 }
272 }
273 }
274
275 /**
276 * Set the primary filter map to the given map of primary filters
277 *
278 * @param primaryFilters
279 * a map of primary filters
280 */
281 public void setPrimaryFilters(Map<String, Set<Object>> primaryFilters) {
282 this.primaryFilters = primaryFilters;
283 }
284
285 /**
286 * Get the other information of the entity
287 *
288 * @return the other information of the entity
289 */
290 @XmlElement(name = "otherinfo")
291 public Map<String, Object> getOtherInfo() {
292 return otherInfo;
293 }
294
295 /**
296 * Add one piece of other information of the entity to the existing other info
297 * map
298 *
299 * @param key
300 * the other information key
301 * @param value
302 * the other information value
303 */
304 public void addOtherInfo(String key, Object value) {
305 this.otherInfo.put(key, value);
306 }
307
308 /**
309 * Add a map of other information of the entity to the existing other info map
310 *
311 * @param otherInfo
312 * a map of other information
313 */
314 public void addOtherInfo(Map<String, Object> otherInfo) {
315 this.otherInfo.putAll(otherInfo);
316 }
317
318 /**
319 * Set the other info map to the given map of other information
320 *
321 * @param otherInfo
322 * a map of other information
323 */
324 public void setOtherInfo(Map<String, Object> otherInfo) {
325 this.otherInfo = otherInfo;
326 }
327
328 @Override
329 public int hashCode() {
330 // generated by eclipse
331 final int prime = 31;
332 int result = 1;
333 result = prime * result + ((entityId == null) ? 0 : entityId.hashCode());
334 result =
335 prime * result + ((entityType == null) ? 0 : entityType.hashCode());
336 result = prime * result + ((events == null) ? 0 : events.hashCode());
337 result = prime * result + ((otherInfo == null) ? 0 : otherInfo.hashCode());
338 result =
339 prime * result
340 + ((primaryFilters == null) ? 0 : primaryFilters.hashCode());
341 result =
342 prime * result
343 + ((relatedEntities == null) ? 0 : relatedEntities.hashCode());
344 result = prime * result + ((startTime == null) ? 0 : startTime.hashCode());
345 return result;
346 }
347
348 @Override
349 public boolean equals(Object obj) {
350 // generated by eclipse
351 if (this == obj)
352 return true;
353 if (obj == null)
354 return false;
355 if (getClass() != obj.getClass())
356 return false;
357 TimelineEntity other = (TimelineEntity) obj;
358 if (entityId == null) {
359 if (other.entityId != null)
360 return false;
361 } else if (!entityId.equals(other.entityId))
362 return false;
363 if (entityType == null) {
364 if (other.entityType != null)
365 return false;
366 } else if (!entityType.equals(other.entityType))
367 return false;
368 if (events == null) {
369 if (other.events != null)
370 return false;
371 } else if (!events.equals(other.events))
372 return false;
373 if (otherInfo == null) {
374 if (other.otherInfo != null)
375 return false;
376 } else if (!otherInfo.equals(other.otherInfo))
377 return false;
378 if (primaryFilters == null) {
379 if (other.primaryFilters != null)
380 return false;
381 } else if (!primaryFilters.equals(other.primaryFilters))
382 return false;
383 if (relatedEntities == null) {
384 if (other.relatedEntities != null)
385 return false;
386 } else if (!relatedEntities.equals(other.relatedEntities))
387 return false;
388 if (startTime == null) {
389 if (other.startTime != null)
390 return false;
391 } else if (!startTime.equals(other.startTime))
392 return false;
393 return true;
394 }
395
396 @Override
397 public int compareTo(TimelineEntity other) {
398 int comparison = entityType.compareTo(other.entityType);
399 if (comparison == 0) {
400 long thisStartTime =
401 startTime == null ? Long.MIN_VALUE : startTime;
402 long otherStartTime =
403 other.startTime == null ? Long.MIN_VALUE : other.startTime;
404 if (thisStartTime > otherStartTime) {
405 return -1;
406 } else if (thisStartTime < otherStartTime) {
407 return 1;
408 } else {
409 return entityId.compareTo(other.entityId);
410 }
411 } else {
412 return comparison;
413 }
414 }
415
416 }