Beispiel #1
0
/**
 * Bean responsible for the agent details display page. This bean will also provide a pagable list
 * of the failover servers for a particular agent.
 *
 * @author Jason Dobies
 */
public class ViewAgentUIBean extends PagedDataTableUIBean {

  public static final String MANAGED_BEAN_NAME = "ViewAgentUIBean";

  private AgentManagerLocal agentManager = LookupUtil.getAgentManager();
  private CloudManagerLocal cloudManager = LookupUtil.getCloudManager();

  private Agent agent;

  public Agent getAgent() {
    if (agent == null) {
      hasPermission();
      int agentId = FacesContextUtility.getRequiredRequestParameter("agentId", Integer.class);
      agent = agentManager.getAgentByID(agentId);
    }
    return agent;
  }

  @Override
  public DataModel getDataModel() {
    if (dataModel == null) {
      dataModel =
          new ViewAgentUIBeanDataModel(PageControlView.AgentFailoverListView, MANAGED_BEAN_NAME);
    }

    return dataModel;
  }

  private class ViewAgentUIBeanDataModel extends PagedListDataModel<FailoverListDetails> {

    private ViewAgentUIBeanDataModel(PageControlView view, String beanName) {
      super(view, beanName);
    }

    @Override
    public PageList<FailoverListDetails> fetchPage(PageControl pc) {
      int agentId = getAgent().getId();
      PageList<FailoverListDetails> pageList =
          cloudManager.getFailoverListDetailsByAgentId(agentId, pc);

      return pageList;
    }
  }

  /** Throws a permission exception if the user is not allowed to access this functionality. */
  private void hasPermission() {
    Subject subject = EnterpriseFacesContextUtility.getSubject();
    if (!LookupUtil.getAuthorizationManager()
        .hasGlobalPermission(subject, Permission.MANAGE_INVENTORY)) {
      throw new PermissionException(
          "User ["
              + subject.getName()
              + "] does not have the proper permissions to view or manage agents");
    }
  }
}
/**
 * Backing bean for the left navigation tree for resources
 *
 * @author Greg Hinkle
 */
public class ResourceTreeModelUIBean {
  private static final Log log = LogFactory.getLog(ResourceTreeModelUIBean.class);

  private List<ResourceTreeNode> roots = new ArrayList<ResourceTreeNode>();
  private ResourceTreeNode rootNode = null;

  private ResourceManagerLocal resourceManager = LookupUtil.getResourceManager();
  private AgentManagerLocal agentManager = LookupUtil.getAgentManager();

  private String nodeTitle;

  private void loadTree() {
    int searchId;
    Resource currentResource = EnterpriseFacesContextUtility.getResourceIfExists();
    if (currentResource == null) {
      searchId = Integer.parseInt(FacesContextUtility.getOptionalRequestParameter("parent"));
    } else {
      searchId = currentResource.getId();
    }

    Subject user = EnterpriseFacesContextUtility.getSubject();

    long start = System.currentTimeMillis();
    long monitorId = HibernatePerformanceMonitor.get().start();
    Resource rootResource = resourceManager.getRootResourceForResource(searchId);
    long end = System.currentTimeMillis();
    HibernatePerformanceMonitor.get().stop(monitorId, "ResourceTree root resource");
    log.debug("Found root resource in " + (end - start));

    Agent agent =
        agentManager.getAgentByResourceId(
            LookupUtil.getSubjectManager().getOverlord(), rootResource.getId());

    start = System.currentTimeMillis();
    monitorId = HibernatePerformanceMonitor.get().start();
    List<ResourceFlyweight> resources =
        resourceManager.findResourcesByAgent(
            user, agent.getId(), PageControl.getUnlimitedInstance());
    end = System.currentTimeMillis();
    HibernatePerformanceMonitor.get().stop(monitorId, "ResourceTree agent resource");
    log.debug("Loaded " + resources.size() + " raw resources in " + (end - start));

    start = System.currentTimeMillis();
    monitorId = HibernatePerformanceMonitor.get().start();
    rootNode = load(rootResource.getId(), resources);
    end = System.currentTimeMillis();
    HibernatePerformanceMonitor.get().stop(monitorId, "ResourceTree tree construction");
    log.debug("Constructed tree in " + (end - start));
  }

  public static ResourceTreeNode load(int rootId, List<ResourceFlyweight> resources) {
    ResourceFlyweight found = null;
    for (ResourceFlyweight res : resources) {
      if (res.getId() == rootId) {
        found = res;
      }
    }
    ResourceTreeNode root = new ResourceTreeNode(found);
    long start = System.currentTimeMillis();
    load(root);
    return root;
  }

  public static void load(ResourceTreeNode parentNode) {
    if (parentNode.getData() instanceof ResourceFlyweight) {
      ResourceFlyweight parentResource = (ResourceFlyweight) parentNode.getData();

      Map<Object, List<ResourceFlyweight>> children =
          new HashMap<Object, List<ResourceFlyweight>>();
      for (ResourceFlyweight res : parentResource.getChildResources()) {
        if (res.getResourceType().getSubCategory() != null) {
          // These are children that have subcategories
          // Split them by if they are a sub-sub category or just a category
          ResourceSubCategoryFlyweight categoryKey =
              res.getResourceType().getSubCategory().getParentSubCategory();
          if (categoryKey == null) {
            categoryKey = res.getResourceType().getSubCategory();
          }
          addToList(children, categoryKey, res);
        } else {
          // These are children without categories of the parent resource
          // - Add them into groupings by their resource type
          addToList(children, res.getResourceType(), res);
        }
      }

      Set<String> dupResourceTypeNames = getDuplicateResourceTypeNames(children);

      for (Map.Entry<Object, List<ResourceFlyweight>> entry : children.entrySet()) {
        Object key = entry.getKey();
        List<ResourceFlyweight> resources = entry.getValue();

        double avail = 0;
        for (ResourceFlyweight res : resources) {
          avail +=
              res.getCurrentAvailability().getAvailabilityType() == AvailabilityType.UP ? 1 : 0;
        }
        avail = avail / resources.size();

        Object nodeData = null;
        if (key instanceof ResourceSubCategoryFlyweight) {
          nodeData =
              new AutoGroupCompositeFlyweight(
                  avail, parentResource, (ResourceSubCategoryFlyweight) key, resources.size());
        } else if (key instanceof ResourceTypeFlyweight) {
          ResourceTypeFlyweight typeKey = (ResourceTypeFlyweight) key;

          if (typeKey.isSingleton()) {
            nodeData = resources.get(0);
          } else {
            boolean isDupResourceTypeName = dupResourceTypeNames.contains(typeKey.getName());
            nodeData =
                new AutoGroupCompositeFlyweight(
                    avail, parentResource, typeKey, resources.size(), isDupResourceTypeName);
          }
        }
        ResourceTreeNode node = new ResourceTreeNode(nodeData, parentNode);
        load(node);

        if (!recursivelyLocked(node)) {
          parentNode.getChildren().add(node);
        }
      }
    } else {
      // #####################################################################################

      AutoGroupCompositeFlyweight compositeParent =
          (AutoGroupCompositeFlyweight) parentNode.getData();

      Map<Object, List<ResourceFlyweight>> children =
          new HashMap<Object, List<ResourceFlyweight>>();
      log.debug("composite parent" + compositeParent);
      if (compositeParent != null) {

        MembersCategoryHint membersCategory = MembersCategoryHint.NONE;
        MembersAvailabilityHint membersAvailabilityHint = MembersAvailabilityHint.UP;

        for (ResourceFlyweight res : compositeParent.getParentResource().getChildResources()) {
          boolean process = false;
          if (compositeParent.getSubcategory() != null) {
            // parent is a sub category
            if (res.getResourceType().getSubCategory() != null
                && compositeParent
                    .getSubcategory()
                    .equals(res.getResourceType().getSubCategory().getParentSubCategory())
                && compositeParent.getParentResource().equals(res.getParentResource())) {

              // A subSubCategory in a subcategory
              addToList(children, res.getResourceType().getSubCategory(), res);
              process = true;
            } else if (compositeParent
                    .getSubcategory()
                    .equals(res.getResourceType().getSubCategory())
                && compositeParent.getParentResource().equals(res.getParentResource())) {
              // Direct entries in a subcategory... now group them by autogroup (type)
              addToList(children, res.getResourceType(), res);
              process = true;
            }
          } else if (compositeParent.getResourceType() != null) {
            if (compositeParent.getResourceType().equals(res.getResourceType())
                && compositeParent.getParentResource().getId() == res.getParentResource().getId()) {

              addToList(children, res.getResourceType(), res);
              process = true;
            }
          }

          if (process) {
            // amend the overall category of all the members of the auto group.
            switch (membersCategory) {
              case NONE: // this is the first child, so let's use its category as a starting point
                membersCategory =
                    MembersCategoryHint.fromResourceCategory(res.getResourceType().getCategory());
                break;
              case MIXED: // this is the "final" state. The children type is not going to change
                          // from this.
                break;
              default: // check if this child has the same category as its previous siblings.
                if (MembersCategoryHint.fromResourceCategory(res.getResourceType().getCategory())
                    != membersCategory) {
                  membersCategory = MembersCategoryHint.MIXED;
                }
            }

            // amend the availability hint of the autogroup. If all resources are up, the hint is
            // UP, if some of the resources
            // are down, the hint is DOWN, if some of the resources' avail state is unknown, the
            // hint is UNKNOWN.
            // The down state has the highest priority.
            switch (membersAvailabilityHint) {
              case UP:
                membersAvailabilityHint =
                    MembersAvailabilityHint.fromAvailabilityType(
                        res.getCurrentAvailability().getAvailabilityType());
                break;
              case UNKNOWN:
                if (res.getCurrentAvailability().getAvailabilityType() == AvailabilityType.DOWN) {
                  membersAvailabilityHint = MembersAvailabilityHint.DOWN;
                }
                break;
              case DOWN:; // a "terminal" state... if some resource is down, the overall state is
                          // going to be down as that is the most important information.
            }
          }
        }

        compositeParent.setMembersCategoryHint(membersCategory);
        compositeParent.setMembersAvailabilityHint(membersAvailabilityHint);
      }

      AutoGroupCompositeFlyweight compositeParentNode =
          (AutoGroupCompositeFlyweight) parentNode.getData();

      for (Map.Entry<Object, List<ResourceFlyweight>> entry : children.entrySet()) {
        Object key = entry.getKey();
        List<ResourceFlyweight> resources = entry.getValue();

        if (compositeParentNode.getSubcategory() != null) {
          double avail = 0;
          for (ResourceFlyweight res : resources) {
            avail +=
                res.getCurrentAvailability().getAvailabilityType() == AvailabilityType.UP ? 1 : 0;
          }
          avail = avail / resources.size();

          Object nodeData = null;
          if (key instanceof ResourceSubCategoryFlyweight) {
            nodeData =
                new AutoGroupCompositeFlyweight(
                    avail,
                    compositeParent.getParentResource(),
                    (ResourceSubCategoryFlyweight) key,
                    resources.size());
          } else if (key instanceof ResourceTypeFlyweight) {
            ResourceTypeFlyweight typeKey = (ResourceTypeFlyweight) key;
            if (typeKey.isSingleton()) {
              nodeData = resources.get(0);
            } else {
              nodeData =
                  new AutoGroupCompositeFlyweight(
                      avail, compositeParent.getParentResource(), typeKey, resources.size(), false);
            }
          }
          ResourceTreeNode node = new ResourceTreeNode(nodeData, parentNode);
          load(node);

          if (!recursivelyLocked(node)) {
            parentNode.getChildren().add(node);
          }
        } else {
          for (ResourceFlyweight res : resources) {
            ResourceTreeNode node = new ResourceTreeNode(res, parentNode);
            load(node);
            if (!recursivelyLocked(node)) {
              parentNode.getChildren().add(node);
            }
          }
        }
      }
    }
  }

  public static boolean recursivelyLocked(ResourceTreeNode node) {
    if (node.getData() instanceof ResourceFlyweight
        && !((ResourceFlyweight) node.getData()).isLocked()) {
      return false;
    }

    boolean allLocked = true;
    for (ResourceTreeNode child : node.getChildren()) {
      if (!recursivelyLocked(child)) allLocked = false;
    }
    return allLocked;
  }

  public ResourceTreeNode getTreeNode() {
    if (rootNode == null) {
      long start = System.currentTimeMillis();
      loadTree();
      log.debug("Loaded full tree in " + (System.currentTimeMillis() - start));
    }

    return rootNode;
  }

  public List<ResourceTreeNode> getRoots() {
    if (roots.isEmpty()) {
      roots.add(getTreeNode());
    }
    return roots;
  }

  public String getNodeTitle() {
    return nodeTitle;
  }

  public void setNodeTitle(String nodeTitle) {
    this.nodeTitle = nodeTitle;
  }

  private static Set<String> getDuplicateResourceTypeNames(
      Map<Object, List<ResourceFlyweight>> children) {
    Set<String> resourceTypeNames = new HashSet<String>();
    Set<String> dupResourceTypeNames = new HashSet<String>();
    for (Object rsc : children.keySet()) {
      if (rsc instanceof ResourceTypeFlyweight) {
        String resourceTypeName = ((ResourceTypeFlyweight) rsc).getName();
        if (resourceTypeNames.contains(resourceTypeName)) {
          dupResourceTypeNames.add(resourceTypeName);
        }
        resourceTypeNames.add(resourceTypeName);
      }
    }
    return dupResourceTypeNames;
  }

  private static <K, V> void addToList(Map<K, List<V>> mapOfLists, K key, V value) {
    List<V> list = mapOfLists.get(key);

    if (list == null) {
      list = new ArrayList<V>();
      mapOfLists.put(key, list);
    }

    list.add(value);
  }
}
/** @author Jiri Kremser */
public class TopologyGWTServiceImpl extends AbstractGWTServiceImpl implements TopologyGWTService {

  private static final long serialVersionUID = 1L;

  private TopologyManagerLocal topologyManager = LookupUtil.getTopologyManager();

  private AgentManagerLocal agentManager = LookupUtil.getAgentManager();

  private PartitionEventManagerLocal partitionEventManager = LookupUtil.getPartitionEventManager();

  private AffinityGroupManagerLocal affinityGroupManager = LookupUtil.getAffinityGroupManager();

  @Override
  public PageList<ServerWithAgentCountComposite> getServers(PageControl pc)
      throws RuntimeException {
    try {
      return SerialUtility.prepare(
          topologyManager.getServerComposites(getSessionSubject(), pc),
          "TopologyGWTServiceImpl.getServers");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void deleteServers(int[] serverIds) throws RuntimeException {
    try {
      topologyManager.deleteServers(getSessionSubject(), ArrayUtils.toObject(serverIds));
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void updateServerManualMaintenance(int[] serverIds, boolean manualMaintenance)
      throws RuntimeException {
    try {
      topologyManager.updateServerManualMaintenance(
          getSessionSubject(), ArrayUtils.toObject(serverIds), manualMaintenance);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public List<FailoverListDetails> getFailoverListDetailsByAgentId(int agentId, PageControl pc)
      throws RuntimeException {
    try {
      return SerialUtility.prepare(
          topologyManager.getFailoverListDetailsByAgentId(getSessionSubject(), agentId, pc),
          "TopologyGWTServiceImpl.getFailoverListDetailsByAgentId");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public PageList<PartitionEvent> findPartitionEventsByCriteria(PartitionEventCriteria criteria)
      throws RuntimeException {
    try {
      return SerialUtility.prepare(
          partitionEventManager.findPartitionEventsByCriteria(getSessionSubject(), criteria),
          "TopologyGWTServiceImpl.findPartitionEventsByCriteria");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public PageList<Server> findServersByCriteria(ServerCriteria criteria) throws RuntimeException {
    try {
      return SerialUtility.prepare(
          topologyManager.findServersByCriteria(getSessionSubject(), criteria),
          "TopologyGWTServiceImpl.findServersByCriteria");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public PageList<Agent> findAgentsByCriteria(AgentCriteria criteria) throws RuntimeException {
    try {
      return SerialUtility.prepare(
          agentManager.findAgentsByCriteria(getSessionSubject(), criteria),
          "TopologyGWTServiceImpl.findAgentsByCriteria");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void cloudPartitionEventRequest() throws RuntimeException {
    try {
      partitionEventManager.cloudPartitionEventRequest(
          getSessionSubject(), PartitionEventType.ADMIN_INITIATED_PARTITION, "");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void purgeAllEvents() throws RuntimeException {
    try {
      partitionEventManager.purgeAllEvents(getSessionSubject());
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void deletePartitionEvents(int[] eventIds) throws RuntimeException {
    try {
      partitionEventManager.deletePartitionEvents(
          getSessionSubject(), ArrayUtils.toObject(eventIds));
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public PageList<PartitionEventDetails> getPartitionEventDetails(
      int partitionEventId, PageControl pageControl) throws RuntimeException {
    try {
      return SerialUtility.prepare(
          partitionEventManager.getPartitionEventDetails(
              getSessionSubject(), partitionEventId, pageControl),
          "TopologyGWTServiceImpl.getPartitionEventDetails");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public PageList<AffinityGroupCountComposite> getAffinityGroupCountComposites(
      PageControl pageControl) throws RuntimeException {
    try {
      return SerialUtility.prepare(
          affinityGroupManager.getComposites(getSessionSubject(), pageControl),
          "TopologyGWTServiceImpl.getAffinityGroupCountComposites");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public int deleteAffinityGroups(int[] affinityGroupIds) throws RuntimeException {
    try {
      return affinityGroupManager.delete(
          getSessionSubject(), ArrayUtils.toObject(affinityGroupIds));
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public int createAffinityGroup(AffinityGroup affinityGroup) throws RuntimeException {
    try {
      return affinityGroupManager.create(getSessionSubject(), affinityGroup);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public AffinityGroup getAffinityGroupById(int affinityGroupId) throws RuntimeException {
    try {
      return SerialUtility.prepare(
          affinityGroupManager.getById(getSessionSubject(), affinityGroupId),
          "TopologyGWTServiceImpl.getAffinityGroupById");
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void addServersToGroup(int affinityGroupId, Integer[] serverIds) throws RuntimeException {
    try {
      affinityGroupManager.addServersToGroup(getSessionSubject(), affinityGroupId, serverIds);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void removeServersFromGroup(Integer[] serverIds) throws RuntimeException {
    try {
      affinityGroupManager.removeServersFromGroup(getSessionSubject(), serverIds);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void addAgentsToGroup(int affinityGroupId, Integer[] agentIds) throws RuntimeException {
    try {
      affinityGroupManager.addAgentsToGroup(getSessionSubject(), affinityGroupId, agentIds);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void removeAgentsFromGroup(Integer[] agentIds) throws RuntimeException {
    try {
      affinityGroupManager.removeAgentsFromGroup(getSessionSubject(), agentIds);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void updateServer(Server server) throws RuntimeException {
    try {
      topologyManager.updateServer(getSessionSubject(), server);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public void updateAffinityGroup(AffinityGroup affinityGroup) throws RuntimeException {
    try {
      affinityGroupManager.update(getSessionSubject(), affinityGroup);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }

  @Override
  public Integer getResourceIdOfAgent(int agentId) throws RuntimeException {
    try {
      return topologyManager.getResourceIdOfAgent(getSessionSubject(), agentId);
    } catch (Throwable t) {
      throw getExceptionToThrowToClient(t);
    }
  }
}
  @Override
  public Set<ResourceMeasurementScheduleRequest> postProcessNewlyCommittedResources(
      Set<Integer> resourceIds) {
    if (log.isDebugEnabled()) {
      log.debug("Post-processing " + resourceIds.size() + "newly committed resources");
      log.debug("Ids were: " + resourceIds);
    }

    Subject overlord = LookupUtil.getSubjectManager().getOverlord();
    AlertTemplateManagerLocal alertTemplateManager = LookupUtil.getAlertTemplateManager();
    MeasurementScheduleManagerLocal scheduleManager = LookupUtil.getMeasurementScheduleManager();
    AgentManagerLocal agentManager = LookupUtil.getAgentManager();
    StatusManagerLocal statusManager = LookupUtil.getStatusManager();

    long start = System.currentTimeMillis();

    // do this in one fell swoop, instead of one resource at a time
    Set<ResourceMeasurementScheduleRequest> results =
        scheduleManager.findSchedulesForResourceAndItsDescendants(
            ArrayUtils.unwrapCollection(resourceIds), false);

    long time = (System.currentTimeMillis() - start);

    if (time >= 10000L) {
      log.info(
          "Performance: commit resource, create schedules timing: resourceCount/millis="
              + resourceIds.size()
              + '/'
              + time);
    } else if (log.isDebugEnabled()) {
      log.debug(
          "Performance: commit resource, create schedules timing: resourceCount/millis="
              + resourceIds.size()
              + '/'
              + time);
    }

    start = System.currentTimeMillis();

    for (Integer resourceId : resourceIds) {
      // apply alert templates
      try {
        alertTemplateManager.updateAlertDefinitionsForResource(overlord, resourceId);
      } catch (AlertDefinitionCreationException adce) {
        /* should never happen because AlertDefinitionCreationException is only ever
         * thrown if updateAlertDefinitionsForResource isn't called as the overlord
         *
         * but we'll log it anyway, just in case, so it isn't just swallowed
         */
        log.error(adce);
      } catch (Throwable t) {
        log.debug("Could not apply alert templates for resourceId = " + resourceId, t);
      }
    }

    try {
      if (resourceIds.size() > 0) {
        // they all come from the same agent, so pick any old one
        int anyResourceIdFromNewlyCommittedSet = resourceIds.iterator().next();
        int agentId = agentManager.getAgentIdByResourceId(anyResourceIdFromNewlyCommittedSet);
        statusManager.updateByAgent(agentId);
      }
    } catch (Throwable t) {
      log.debug("Could not reload caches for newly committed resources", t);
    }

    time = (System.currentTimeMillis() - start);

    if (time >= 10000L) {
      log.info(
          "Performance: commit resource, apply alert templates timing: resourceCount/millis="
              + resourceIds.size()
              + '/'
              + time);
    } else if (log.isDebugEnabled()) {
      log.debug(
          "Performance: commit resource, apply alert templates timing: resourceCount/millis="
              + resourceIds.size()
              + '/'
              + time);
    }

    return results;
  }