public String toString() { return "[" + resourceId + "] " + resource.getName() + " (" + resource.getResourceType().getName() + "::" + resource.getResourceType().getPlugin() + ")"; }
private void initConfigDefs() { this.resourceConfigurationDefinition = remoteClient .getConfigurationManager() .getResourceConfigurationDefinitionWithTemplatesForResourceType( remoteClient.getSubject(), resource.getResourceType().getId()); this.pluginConfigurationDefinition = remoteClient .getConfigurationManager() .getPluginConfigurationDefinitionForResourceType( remoteClient.getSubject(), resource.getResourceType().getId()); }
public void init() { this.resource = remoteClient.getResourceManager().getResource(remoteClient.getSubject(), resourceId); // Lazy init children, not here initMeasurements(); initOperations(); initConfigDefs(); initContent(); List<PackageType> packageTypes = new ArrayList<PackageType>(); for (ContentType ct : contentTypes.values()) { packageTypes.add(ct.getPackageType()); } fingerprint = new ResourceTypeFingerprint( resource.getResourceType(), measurementDefinitions, operationDefinitions, packageTypes, pluginConfigurationDefinition, resourceConfigurationDefinition); }
@Override protected void onInit() { // To properly filter Create Child and Import menus we need existing singleton child resources. // If the // user has create permission and the parent type has singleton child types and creatable or // importable child // types, perform an async call to fetch the singleton children. If we make the async call don't // declare this // instance initialized until after it completes as we must have the children before the menu // buttons can be drawn. final Resource parentResource = parentResourceComposite.getResource(); ResourceType parentType = parentResource.getResourceType(); creatableChildTypes = getCreatableChildTypes(parentType); importableChildTypes = getImportableChildTypes(parentType); hasCreatableTypes = !creatableChildTypes.isEmpty(); hasImportableTypes = !importableChildTypes.isEmpty(); refreshSingletons( parentResource, new AsyncCallback<PageList<Resource>>() { public void onFailure(Throwable caught) { ResourceCompositeSearchView.super.onInit(); initialized = true; } public void onSuccess(PageList<Resource> result) { ResourceCompositeSearchView.super.onInit(); initialized = true; } }); }
@Override public ListGridRecord copyValues(AlertDefinition from) { // in order to support sorting our list grid on the parent and resource columns, // we have to assign these to something that is sortable ListGridRecord record = super.copyValues(from); Resource resource = from.getResource(); record.setAttribute(FIELD_RESOURCE, resource.getName()); Integer parentId = from.getParentId(); // a valid non-zero number means the alert def came from a template AlertDefinition groupAlertDefinition = from.getGroupAlertDefinition(); if (parentId != null && parentId.intValue() > 0) { record.setAttribute(FIELD_PARENT, "<b>" + MSG.view_alert_definition_for_type() + "</b>"); } else if (groupAlertDefinition != null) { record.setAttribute(FIELD_PARENT, "<b>" + MSG.view_alert_definition_for_group() + "</b>"); } // for ancestry handling record.setAttribute(AncestryUtil.RESOURCE_ID, resource.getId()); record.setAttribute(AncestryUtil.RESOURCE_NAME, resource.getName()); record.setAttribute(AncestryUtil.RESOURCE_ANCESTRY, resource.getAncestry()); record.setAttribute(AncestryUtil.RESOURCE_TYPE_ID, resource.getResourceType().getId()); return record; }
private void setTitle(HttpServletRequest request, Portal portal, String titleName) throws Exception { Resource resource = RequestUtils.getResource(request); ResourceGroup group = RequestUtils.getResourceGroupIfExists(request); ResourceType type; if (resource != null) { // resource alert definition type = resource.getResourceType(); } else if (group != null) { // group alert definition type = group.getResourceType(); } else { // template alert definition type = RequestUtils.getResourceType(request); } ResourceCategory category = type.getCategory(); titleName = StringUtil.replace(titleName, "platform", category.toString().toLowerCase()); portal.setName(titleName); // if there's an alert definition available, set our second // title parameter to its name try { AlertDefinition alertDef = AlertDefUtil.getAlertDefinition(request); request.setAttribute(Constants.TITLE_PARAM2_ATTR, alertDef.getName()); } catch (ParameterNotFoundException e) { // it's okay log.trace("couldn't find alert definition: " + e.getMessage()); } }
private static Resource convertToPojoResource(Resource resource, boolean includeDescendants) { Resource pojoResource = new Resource(resource.getId()); pojoResource.setUuid(resource.getUuid()); pojoResource.setResourceKey(resource.getResourceKey()); pojoResource.setResourceType(resource.getResourceType()); pojoResource.setMtime(resource.getMtime()); pojoResource.setInventoryStatus(resource.getInventoryStatus()); Configuration pcCopy = resource.getPluginConfiguration(); if (pcCopy != null) { pcCopy = pcCopy.deepCopy(); } pojoResource.setPluginConfiguration(pcCopy); pojoResource.setName(resource.getName()); pojoResource.setDescription(resource.getDescription()); pojoResource.setLocation(resource.getLocation()); pojoResource.setVersion(resource.getVersion()); if (resource.getParentResource() != null) { pojoResource.setParentResource(convertToPojoResource(resource.getParentResource(), false)); } if (includeDescendants) { for (Resource childResource : resource.getChildResources()) { if (isVisibleInInventory(childResource)) { pojoResource.addChildResource(convertToPojoResource(childResource, true)); } } } return pojoResource; }
/** * Tests that the JON Agent can be discovered. * * @throws Exception */ public void testServerDiscovery() throws Exception { InventoryReport report = pc.getInventoryManager().executeServerScanImmediately(); assert report != null; Resource platform = pc.getInventoryManager().getPlatform(); Set<Resource> servers = platform.getChildResources(); assert servers.size() > 0; Resource agent_resource = servers.iterator().next(); assert agent_resource.getName().indexOf("RHQ Agent") > -1 : "Bad name: " + agent_resource.getName(); assert agent_resource.getResourceType().getName().equals(AGENT_RESOURCE_TYPE_NAME) : "Bad type: " + agent_resource.getResourceType(); assert agent_resource.getResourceType().getCategory() == ResourceCategory.SERVER : "Bad type: " + agent_resource.getResourceType(); pc.getInventoryManager().executeServiceScanImmediately(); InventoryPrinter.outputInventory(new PrintWriter(System.out), false); }
private Set<Resource> getDiscoveredServers() { Set<Resource> found = new HashSet<Resource>(); Resource platform = PluginContainer.getInstance().getInventoryManager().getPlatform(); for (Resource resource : platform.getChildResources()) { if (resource.getResourceType().getName().equals("Postgres Server")) { found.add(resource); } } return found; }
private void buildFavoriteResourcesMenu( Favorites favorites, Menu menu, Set<Integer> resourceIds, AncestryUtil.MapWrapper typesWrapper) { if (resourceIds.isEmpty()) { menu.setItems(); return; } List<MenuItem> items = new ArrayList<MenuItem>(resourceIds.size()); for (final Integer resourceId : resourceIds) { Resource resource = favorites.getResource(resourceId); if (null == resource) { // if the resource is gone just skip it continue; } MenuItem item = new MenuItem(resource.getName()); item.setIcon(ImageManager.getResourceIcon(resource)); // build a subMenu to display a disambiguated resource item.setAttribute(AncestryUtil.RESOURCE_ID, resourceId); item.setAttribute(AncestryUtil.RESOURCE_NAME, resource.getName()); item.setAttribute(AncestryUtil.RESOURCE_ANCESTRY, resource.getAncestry()); item.setAttribute(AncestryUtil.RESOURCE_TYPE_ID, resource.getResourceType().getId()); item.setAttribute(AncestryUtil.RESOURCE_ANCESTRY_TYPES, typesWrapper); Menu ancestryMenu = new Menu(); MenuItem ancestryItem = new MenuItem(AncestryUtil.getAncestryHoverHTML(item, -1)); ancestryItem.setEnabled(false); ancestryMenu.setItems(ancestryItem); ancestryMenu.setSubmenuDirection("left"); ancestryMenu.setAutoWidth(); item.setSubmenu(ancestryMenu); item.addClickHandler( new com.smartgwt.client.widgets.menu.events.ClickHandler() { public void onClick(MenuItemClickEvent event) { CoreGUI.goToView(LinkManager.getResourceLink(resourceId)); } }); items.add(item); } menu.setCanSelectParentItems(Boolean.TRUE); menu.setItems(items.toArray(new MenuItem[items.size()])); }
private List<Resource> findResources( Resource parent, String typeName, List<Resource> foundResources) { if (parent.getResourceType().getName().equals(typeName)) { foundResources.add(parent); } for (Resource resource : parent.getChildResources()) { for (Resource child : resource.getChildResources()) { findResources(child, typeName, foundResources); } } return foundResources; }
/** * Additional processing to support a cross-resource view) * * @param result * @param response * @param request */ protected void dataRetrieved( final PageList<AlertDefinition> result, final DSResponse response, final DSRequest request) { HashSet<Integer> typesSet = new HashSet<Integer>(); HashSet<String> ancestries = new HashSet<String>(); for (AlertDefinition alertDefinition : result) { Resource resource = alertDefinition.getResource(); if (null != resource) { typesSet.add(resource.getResourceType().getId()); ancestries.add(resource.getAncestry()); } } // In addition to the types of the result resources, get the types of their ancestry typesSet.addAll(AncestryUtil.getAncestryTypeIds(ancestries)); ResourceTypeRepository typeRepo = ResourceTypeRepository.Cache.getInstance(); typeRepo.getResourceTypes( typesSet.toArray(new Integer[typesSet.size()]), new TypesLoadedCallback() { public void onTypesLoaded(Map<Integer, ResourceType> types) { // Smartgwt has issues storing a Map as a ListGridRecord attribute. Wrap it in a pojo. AncestryUtil.MapWrapper typesWrapper = new AncestryUtil.MapWrapper(types); Record[] records = buildRecords(result); for (Record record : records) { // To avoid a lot of unnecessary String construction, be lazy about building // ancestry hover text. // Store the types map off the records so we can build a detailed hover string as // needed. record.setAttribute(AncestryUtil.RESOURCE_ANCESTRY_TYPES, typesWrapper); // Build the decoded ancestry Strings now for display record.setAttribute( AncestryUtil.RESOURCE_ANCESTRY_VALUE, AncestryUtil.getAncestryValue(record)); } response.setData(records); response.setTotalRows( result .getTotalSize()); // for paging to work we have to specify size of full result // set processResponse(request.getRequestId(), response); } }); }
private void deleteNewResource(Resource resource) throws Exception { if (null != resource) { EntityManager em = null; try { ResourceManagerLocal resourceManager = LookupUtil.getResourceManager(); // invoke bulk delete on the resource to remove any dependencies not defined in the // hibernate entity model // perform in-band and out-of-band work in quick succession List<Integer> deletedIds = resourceManager.uninventoryResource(overlord, resource.getId()); for (Integer deletedResourceId : deletedIds) { resourceManager.uninventoryResourceAsyncWork(overlord, deletedResourceId); } // now dispose of other hibernate entities getTransactionManager().begin(); em = getEntityManager(); ResourceType type = em.find(ResourceType.class, resource.getResourceType().getId()); Agent agent = em.find(Agent.class, resource.getAgent().getId()); if (null != agent) { em.remove(agent); } if (null != type) { em.remove(type); } getTransactionManager().commit(); } catch (Exception e) { try { System.out.println( "CANNOT CLEAN UP TEST (" + this.getClass().getSimpleName() + ") Cause: " + e); getTransactionManager().rollback(); } catch (Exception ignore) { } } finally { if (null != em) { em.close(); } } } }
private void initContent() { ContentManagerRemote contentManager = remoteClient.getContentManager(); List<PackageType> types = null; try { types = contentManager.findPackageTypes( remoteClient.getSubject(), resource.getResourceType().getName(), resource.getResourceType().getPlugin()); for (PackageType packageType : types) { contentTypes.put(packageType.getName(), new ContentType(packageType)); } } catch (ResourceTypeNotFoundException e) { LOG.error( "Could not find resource type while creating content mappings of the resource proxy for resource with id " + resourceId, e); } }
private void initMeasurements() { MeasurementDefinitionCriteria criteria = new MeasurementDefinitionCriteria(); criteria.addFilterResourceTypeId(resource.getResourceType().getId()); // criteria.addFilterResourceTypeName(resource.getResourceType().getName()); // criteria.setStrict(true); this.measurementDefinitions = remoteClient .getMeasurementDefinitionManager() .findMeasurementDefinitionsByCriteria(remoteClient.getSubject(), criteria); this.measurementMap = new HashMap<String, Measurement>(); for (MeasurementDefinition def : measurementDefinitions) { Measurement m = new Measurement(def); String name = def.getDisplayName().replaceAll("\\W", ""); name = decapitalize(name); this.measurementMap.put(name, m); this.allProperties.put(name, m); } }
private void refreshSingletons( final Resource parentResource, final AsyncCallback<PageList<Resource>> callback) { singletonChildren = new ArrayList<Resource>(); // initialize to non-null Integer[] singletonChildTypes = getSingletonChildTypes(parentResource.getResourceType()); if (canCreate && singletonChildTypes.length > 0 && (hasCreatableTypes || hasImportableTypes)) { ResourceCriteria criteria = new ResourceCriteria(); criteria.addFilterParentResourceId(parentResource.getId()); criteria.addFilterResourceTypeIds(singletonChildTypes); GWTServiceLookup.getResourceService() .findResourcesByCriteria( criteria, new AsyncCallback<PageList<Resource>>() { @Override public void onSuccess(PageList<Resource> result) { singletonChildren = result; if (callback != null) { callback.onSuccess(result); } } @Override public void onFailure(Throwable caught) { Log.error("Failed to load child resources for [" + parentResource + "]", caught); if (callback != null) { callback.onFailure(caught); } } }); } else { if (callback != null) { callback.onSuccess(new PageList<Resource>()); } } }
private void removeExistingSingletons( List<Resource> singletonChildren, Map<String, ResourceType> displayNameMap) { List<String> existingSingletons = new ArrayList<String>(); Set<String> displayNames = displayNameMap.keySet(); for (final String displayName : displayNames) { final ResourceType type = displayNameMap.get(displayName); boolean exists = false; if (type.isSingleton()) { for (Resource child : singletonChildren) { exists = child.getResourceType().equals(displayNameMap.get(displayName)); if (exists) { existingSingletons.add(displayName); break; } } } } for (String existing : existingSingletons) { displayNameMap.remove(existing); } }
public ResourceType getResourceType() { return resource.getResourceType(); }
private void buildRecentlyViewedMenu( Favorites favorites, Menu menu, List<Integer> recentResourceIds, List<Integer> recentGroupIds, AncestryUtil.MapWrapper typesWrapper) { if (recentResourceIds.isEmpty() && recentGroupIds.isEmpty()) { return; } List<MenuItem> items = new ArrayList<MenuItem>(recentResourceIds.size() + recentGroupIds.size() + 1); for (final Integer resourceId : recentResourceIds) { Resource resource = favorites.getResource(resourceId); if (null == resource) { // if the resource is gone just skip it continue; } MenuItem item = new MenuItem(resource.getName()); item.setIcon(ImageManager.getResourceIcon(resource)); // build a subMenu to display a disambiguated resource item.setAttribute(AncestryUtil.RESOURCE_ID, resourceId); item.setAttribute(AncestryUtil.RESOURCE_NAME, resource.getName()); item.setAttribute(AncestryUtil.RESOURCE_ANCESTRY, resource.getAncestry()); item.setAttribute(AncestryUtil.RESOURCE_TYPE_ID, resource.getResourceType().getId()); item.setAttribute(AncestryUtil.RESOURCE_ANCESTRY_TYPES, typesWrapper); Menu ancestryMenu = new Menu(); MenuItem ancestryItem = new MenuItem(AncestryUtil.getAncestryHoverHTML(item, -1)); ancestryItem.setEnabled(false); ancestryMenu.setItems(ancestryItem); ancestryMenu.setSubmenuDirection("left"); ancestryMenu.setAutoWidth(); item.setSubmenu(ancestryMenu); item.addClickHandler( new com.smartgwt.client.widgets.menu.events.ClickHandler() { public void onClick(MenuItemClickEvent event) { CoreGUI.goToView(LinkManager.getResourceLink(resourceId)); } }); items.add(item); } if (!recentResourceIds.isEmpty() && !recentGroupIds.isEmpty()) { items.add(new MenuItemSeparator()); } for (final Integer groupId : recentGroupIds) { ResourceGroupComposite groupComposite = favorites.getGroupComposite(groupId); if (null == groupComposite) { // if the resource group is gone just skip it continue; } final ResourceGroup group = groupComposite.getResourceGroup(); MenuItem item = new MenuItem(String.valueOf(groupId)); item.setTitle(group.getName()); item.setIcon( ImageManager.getGroupIcon( group.getGroupCategory(), groupComposite.getExplicitAvailabilityType())); item.addClickHandler( new com.smartgwt.client.widgets.menu.events.ClickHandler() { public void onClick(MenuItemClickEvent event) { CoreGUI.goToView(LinkManager.getResourceGroupLink(group)); } }); items.add(item); } menu.setCanSelectParentItems(Boolean.TRUE); menu.setItems(items.toArray(new MenuItem[items.size()])); }
private ResourceGroup createPlatformGroup(String groupName, Resource resource) { ResourceGroup group = new ResourceGroup(groupName, resource.getResourceType()); group.addExplicitResource(resource); return resourceGroupManager.createResourceGroup(overlord, group); }
/** * Given a deployment, this examines the destination and the resource to determine where exactly * the bundle distribution should be written. * * @param bundleResourceDeployment describes where the bundle should be or is deployed * @return absolute directory location where the bundle should be deployed */ private File getAbsoluteDestinationDir(BundleResourceDeployment bundleResourceDeployment) { BundleDestination dest = bundleResourceDeployment.getBundleDeployment().getDestination(); String destBaseDirName = dest.getDestinationBaseDirectoryName(); String relativeDeployDir = dest.getDeployDir(); // paranoia, if no deploy dir is given, as assume it will be directly under the base location if (relativeDeployDir == null || relativeDeployDir.trim().length() == 0) { relativeDeployDir = File.separator; } // get the resource entity stored in our local inventory InventoryManager im = getInventoryManager(); Resource resource = bundleResourceDeployment.getResource(); ResourceContainer container = im.getResourceContainer(resource); resource = container.getResource(); // find out the type of base location that is specified by the bundle destination BundleDestinationBaseDirectory bundleDestBaseDir = null; ResourceTypeBundleConfiguration rtbc = resource.getResourceType().getResourceTypeBundleConfiguration(); if (rtbc == null) { throw new IllegalArgumentException( "The resource type doesn't support bundle deployments: " + resource); } for (BundleDestinationBaseDirectory bdbd : rtbc.getBundleDestinationBaseDirectories()) { if (bdbd.getName().equals(destBaseDirName)) { bundleDestBaseDir = bdbd; break; } } if (bundleDestBaseDir == null) { throw new IllegalArgumentException( "The resource type doesn't support bundle destination base location named [" + destBaseDirName + "]"); } // based on the type of destination base location, determine the root base directory String destBaseDirValueName = bundleDestBaseDir.getValueName(); // the name we look up in the given context String baseLocation; switch (bundleDestBaseDir.getValueContext()) { case fileSystem: { if (!new File(relativeDeployDir).isAbsolute()) { // the deploy dir is not absolute; since we need to pin it to something, we assume the // top root directory // unless the descriptor told us to go somewhere else differently baseLocation = destBaseDirValueName; // ultimately this came from the plugin descriptor if (baseLocation == null || baseLocation.trim().length() == 0) { baseLocation = File .separator; // paranoia, if the plugin descriptor didn't specify, assume the // top root directory } } else { baseLocation = null; // so the relativeDeployDir is processed as an absolute dir } break; } case pluginConfiguration: { baseLocation = resource.getPluginConfiguration().getSimpleValue(destBaseDirValueName, null); if (baseLocation == null) { throw new IllegalArgumentException( "Cannot determine the bundle base deployment location - " + "there is no plugin configuration setting for [" + destBaseDirValueName + "]"); } break; } case resourceConfiguration: { baseLocation = resource.getResourceConfiguration().getSimpleValue(destBaseDirValueName, null); if (baseLocation == null) { throw new IllegalArgumentException( "Cannot determine the bundle base deployment location - " + "there is no resource configuration setting for [" + destBaseDirValueName + "]"); } break; } case measurementTrait: { baseLocation = getMeasurementManager().getTraitValue(container, destBaseDirValueName); if (baseLocation == null) { throw new IllegalArgumentException( "Cannot obtain trait [" + destBaseDirName + "] for resource [" + resource.getName() + "]"); } break; } default: { throw new IllegalArgumentException( "Unknown bundle destination location context: " + bundleDestBaseDir); } } File destDir = new File(baseLocation, relativeDeployDir); if (!destDir.isAbsolute()) { throw new IllegalArgumentException( "The base location path specified by [" + destBaseDirValueName + "] in the context [" + bundleDestBaseDir.getValueContext() + "] along with the destination directory of [" + relativeDeployDir + "] did not resolve to an absolute path [" + destDir.getPath() + "] so there is no way to know where to put the bundle."); } return destDir; }
public void checkConfigurations(Resource resource, boolean checkChildren) { ResourceContainer resourceContainer = this.inventoryManager.getResourceContainer(resource); ConfigurationFacet resourceComponent = null; ResourceType resourceType = resource.getResourceType(); if (resourceContainer != null && resourceContainer.getAvailability() != null && resourceContainer.getAvailability().getAvailabilityType() == AvailabilityType.UP) { try { resourceComponent = resourceContainer.createResourceComponentProxy( ConfigurationFacet.class, FacetLockType.NONE, CONFIGURATION_CHECK_TIMEOUT, true, false); } catch (PluginContainerException e) { // Expecting when the resource does not support configuration management } if (resourceComponent != null) { // Only report availability for committed resources; don't bother with new, ignored or // deleted resources. if (resource.getInventoryStatus() == InventoryStatus.COMMITTED && resourceType.getResourceConfigurationDefinition() != null) { if (log.isErrorEnabled()) log.debug("Checking for updated resource configuration on: " + resource); ConfigurationUpdateRequest request = new ConfigurationUpdateRequest( 0, resource.getResourceConfiguration(), resource.getId()); try { Configuration liveConfiguration = resourceComponent.loadResourceConfiguration(); if (liveConfiguration != null) { ConfigurationDefinition configurationDefinition = resourceType.getResourceConfigurationDefinition(); // Normalize and validate the config. ConfigurationUtility.normalizeConfiguration( liveConfiguration, configurationDefinition); List<String> errorMessages = ConfigurationUtility.validateConfiguration( liveConfiguration, configurationDefinition); for (String errorMessage : errorMessages) { log.warn( "Plugin Error: Invalid " + resourceType.getName() + " resource configuration returned by " + resourceType.getPlugin() + " plugin - " + errorMessage); } Configuration original = resource.getResourceConfiguration(); if (!liveConfiguration.equals(original)) { log.info("New configuration version detected on resource: " + resource); this.configurationServerService.persistUpdatedResourceConfiguration( resource.getId(), liveConfiguration); resource.setResourceConfiguration(liveConfiguration); } } } catch (Throwable t) { log.warn("Unable to check for updated configuration", t); } } } if (checkChildren) { // Avoid concurrent mod exceptions during potentially long duration issues Set<Resource> childSet = new HashSet<Resource>(resource.getChildResources()); for (Resource child : childSet) { try { checkConfigurations(child, true); } catch (Exception e) { e.printStackTrace(); } } } } }
@Summary(index = 3) public ResourceType getResourceType() { return resource.getResourceType(); }