Java TimelineEvent.getTimestamp方法代码示例

import org.apache.hadoop.yarn.api.records.timeline.TimelineEvent; //导入方法依赖的package包/类
/**
 * Get the unique start time for a given entity as a byte array that sorts the
 * timestamps in reverse order (see
 * {@link GenericObjectMapper#writeReverseOrderedLong(long)}). If the start
 * time doesn't exist, set it based on the information provided. Should only
 * be called when a lock has been obtained on the entity.
 *
 * @param entityId
 *          The id of the entity
 * @param entityType
 *          The type of the entity
 * @param startTime
 *          The start time of the entity, or null
 * @param events
 *          A list of events for the entity, or null
 * @return A StartAndInsertTime
 * @throws IOException
 */
private Long getAndSetStartTime(String entityId, String entityType,
    Long startTime, List<TimelineEvent> events) throws IOException {
  EntityIdentifier entity = new EntityIdentifier(entityId, entityType);
  Long time = startTimeWriteCache.get(entity);
  if (time != null) {
    // return the value in the cache
    return time;
  }
  if (startTime == null && events != null) {
    // calculate best guess start time based on lowest event time
    startTime = Long.MAX_VALUE;
    for (TimelineEvent e : events) {
      if (e.getTimestamp() < startTime) {
        startTime = e.getTimestamp();
      }
    }
  }
  // check the provided start time matches the db
  return checkStartTimeInDb(entity, startTime);
}
 

import org.apache.hadoop.yarn.api.records.timeline.TimelineEvent; //导入方法依赖的package包/类
/**
 * Get the unique start time for a given entity as a byte array that sorts the
 * timestamps in reverse order (see
 * {@link GenericObjectMapper#writeReverseOrderedLong(long)}). If the start
 * time doesn't exist, set it based on the information provided.
 *
 * @param entityId
 *          The id of the entity
 * @param entityType
 *          The type of the entity
 * @param startTime
 *          The start time of the entity, or null
 * @param events
 *          A list of events for the entity, or null
 * @return A StartAndInsertTime
 * @throws IOException
 */
private Long getAndSetStartTime(String entityId,
    String entityType, Long startTime, List<TimelineEvent> events)
    throws IOException {
  EntityIdentifier entity = new EntityIdentifier(entityId, entityType);
  Long time = startTimeWriteCache.get(entity);
  if (time != null) {
    // return the value in the cache
    return time;
  }
  if (startTime == null && events != null) {
    // calculate best guess start time based on lowest event time
    startTime = Long.MAX_VALUE;
    for (TimelineEvent e : events) {
      if (e.getTimestamp() < startTime) {
        startTime = e.getTimestamp();
      }
    }
  }
  // check the provided start time matches the db
  return checkStartTimeInDb(entity, startTime);
}
 

import org.apache.hadoop.yarn.api.records.timeline.TimelineEvent; //导入方法依赖的package包/类
/**
 * Get the unique start time for a given entity as a byte array that sorts
 * the timestamps in reverse order (see {@link
 * GenericObjectMapper#writeReverseOrderedLong(long)}). If the start time
 * doesn't exist, set it based on the information provided. Should only be
 * called when a lock has been obtained on the entity.
 *
 * @param entityId The id of the entity
 * @param entityType The type of the entity
 * @param startTime The start time of the entity, or null
 * @param events A list of events for the entity, or null
 * @return A StartAndInsertTime
 * @throws IOException
 */
private StartAndInsertTime getAndSetStartTime(String entityId,
    String entityType, Long startTime, List<TimelineEvent> events)
    throws IOException {
  EntityIdentifier entity = new EntityIdentifier(entityId, entityType);
  if (startTime == null) {
    // start time is not provided, so try to look it up
    if (startTimeWriteCache.containsKey(entity)) {
      // found the start time in the cache
      return startTimeWriteCache.get(entity);
    } else {
      if (events != null) {
        // prepare a start time from events in case it is needed
        Long min = Long.MAX_VALUE;
        for (TimelineEvent e : events) {
          if (min > e.getTimestamp()) {
            min = e.getTimestamp();
          }
        }
        startTime = min;
      }
      return checkStartTimeInDb(entity, startTime);
    }
  } else {
    // start time is provided
    if (startTimeWriteCache.containsKey(entity)) {
      // always use start time from cache if it exists
      return startTimeWriteCache.get(entity);
    } else {
      // check the provided start time matches the db
      return checkStartTimeInDb(entity, startTime);
    }
  }
}
 

import org.apache.hadoop.yarn.api.records.timeline.TimelineEvent; //导入方法依赖的package包/类
@Override
public synchronized TimelineEvents getEntityTimelines(String entityType,
    SortedSet<String> entityIds, Long limit, Long windowStart,
    Long windowEnd,
    Set<String> eventTypes) {
  TimelineEvents allEvents = new TimelineEvents();
  if (entityIds == null) {
    return allEvents;
  }
  if (limit == null) {
    limit = DEFAULT_LIMIT;
  }
  if (windowStart == null) {
    windowStart = Long.MIN_VALUE;
  }
  if (windowEnd == null) {
    windowEnd = Long.MAX_VALUE;
  }
  for (String entityId : entityIds) {
    EntityIdentifier entityID = new EntityIdentifier(entityId, entityType);
    TimelineEntity entity = entities.get(entityID);
    if (entity == null) {
      continue;
    }
    EventsOfOneEntity events = new EventsOfOneEntity();
    events.setEntityId(entityId);
    events.setEntityType(entityType);
    for (TimelineEvent event : entity.getEvents()) {
      if (events.getEvents().size() >= limit) {
        break;
      }
      if (event.getTimestamp() <= windowStart) {
        continue;
      }
      if (event.getTimestamp() > windowEnd) {
        continue;
      }
      if (eventTypes != null && !eventTypes.contains(event.getEventType())) {
        continue;
      }
      events.addEvent(event);
    }
    allEvents.addEvent(events);
  }
  return allEvents;
}
 

import org.apache.hadoop.yarn.api.records.timeline.TimelineEvent; //导入方法依赖的package包/类
@Override
public synchronized TimelineEvents getEntityTimelines(String entityType,
    SortedSet<String> entityIds, Long limit, Long windowStart,
    Long windowEnd,
    Set<String> eventTypes) {
  if (getServiceStopped()) {
    LOG.info("Service stopped, return null for the storage");
    return null;
  }
  TimelineEvents allEvents = new TimelineEvents();
  if (entityIds == null) {
    return allEvents;
  }
  if (limit == null) {
    limit = DEFAULT_LIMIT;
  }
  if (windowStart == null) {
    windowStart = Long.MIN_VALUE;
  }
  if (windowEnd == null) {
    windowEnd = Long.MAX_VALUE;
  }
  for (String entityId : entityIds) {
    EntityIdentifier entityID = new EntityIdentifier(entityId, entityType);
    TimelineEntity entity = entities.get(entityID);
    if (entity == null) {
      continue;
    }
    EventsOfOneEntity events = new EventsOfOneEntity();
    events.setEntityId(entityId);
    events.setEntityType(entityType);
    for (TimelineEvent event : entity.getEvents()) {
      if (events.getEvents().size() >= limit) {
        break;
      }
      if (event.getTimestamp() <= windowStart) {
        continue;
      }
      if (event.getTimestamp() > windowEnd) {
        continue;
      }
      if (eventTypes != null && !eventTypes.contains(event.getEventType())) {
        continue;
      }
      events.addEvent(event);
    }
    allEvents.addEvent(events);
  }
  return allEvents;
}
 

import org.apache.hadoop.yarn.api.records.timeline.TimelineEvent; //导入方法依赖的package包/类
@Override
public TimelineEvents getEntityTimelines(String entityType,
    SortedSet<String> entityIds, Long limit, Long windowStart,
    Long windowEnd,
    Set<String> eventTypes) {
  TimelineEvents allEvents = new TimelineEvents();
  if (entityIds == null) {
    return allEvents;
  }
  if (limit == null) {
    limit = DEFAULT_LIMIT;
  }
  if (windowStart == null) {
    windowStart = Long.MIN_VALUE;
  }
  if (windowEnd == null) {
    windowEnd = Long.MAX_VALUE;
  }
  for (String entityId : entityIds) {
    EntityIdentifier entityID = new EntityIdentifier(entityId, entityType);
    TimelineEntity entity = entities.get(entityID);
    if (entity == null) {
      continue;
    }
    EventsOfOneEntity events = new EventsOfOneEntity();
    events.setEntityId(entityId);
    events.setEntityType(entityType);
    for (TimelineEvent event : entity.getEvents()) {
      if (events.getEvents().size() >= limit) {
        break;
      }
      if (event.getTimestamp() <= windowStart) {
        continue;
      }
      if (event.getTimestamp() > windowEnd) {
        continue;
      }
      if (eventTypes != null && !eventTypes.contains(event.getEventType())) {
        continue;
      }
      events.addEvent(event);
    }
    allEvents.addEvent(events);
  }
  return allEvents;
}