/** * Tells the Agent to asynchronously update a managed resource's configuration as per the specified * <code>ResourceConfigurationUpdate</code>. */ private void executeResourceConfigurationUpdate(ResourceConfigurationUpdate update) { try { AgentClient agentClient = agentManager.getAgentClient(update.getResource().getAgent()); ConfigurationUpdateRequest request = new ConfigurationUpdateRequest(update.getId(), update.getConfiguration(), update.getResource().getId()); agentClient.getConfigurationAgentService().updateResourceConfiguration(request); } catch (RuntimeException e) { // Any exception means the remote call itself failed - make sure to change the status on the update to FAILURE // and set its error message field. if (null != update) { update.setStatus(ConfigurationUpdateStatus.FAILURE); update.setErrorMessage(ThrowableUtil.getStackAsString(e)); // Here we call ourselves, but we do so via the EJB interface so we pick up the REQUIRES_NEW semantics. this.configurationManager.mergeConfigurationUpdate(update); checkForCompletedGroupResourceConfigurationUpdate(update.getId()); } } }
@Override public AbstractGroupConfigurationUpdate getAbstractGroupConfigurationUpdate() { return getGroupConfigurationUpdate(); }
private String toCSV(ResourceConfigurationUpdate configurationUpdate) { return configurationUpdate.getId() + "," + formatDateTime(configurationUpdate.getCreatedTime())+"," + formatDateTime(configurationUpdate.getModifiedTime())+"," + configurationUpdate.getStatus()+"," + cleanForCSV(configurationUpdate.getResource().getName())+ "," + cleanForCSV(ReportFormatHelper.parseAncestry(configurationUpdate.getResource().getAncestry())) + "," + getDetailsURL(configurationUpdate); //@todo: check dates, user, update-type }
private String getDetailsURL(ResourceConfigurationUpdate configUpdate) { String protocol; if (request.isSecure()) { protocol = "https"; } else { protocol = "http"; } return protocol + "://" + request.getServerName() + ":" + request.getServerPort() + "/coregui/#Resource/" + configUpdate.getResource().getId() + "/Configuration/History/" + configUpdate.getId(); } };
@SuppressWarnings("unchecked") private void checkForTimedOutResourceConfigurationUpdateRequests() { try { // TODO (ips): Optimize this so the query actually does the timeout check too, // i.e. "WHERE cu.createdtime > :maxCreatedTime". Query query = entityManager.createNamedQuery(ResourceConfigurationUpdate.QUERY_FIND_ALL_IN_STATUS); query.setParameter("status", ConfigurationUpdateStatus.INPROGRESS); List<ResourceConfigurationUpdate> requests = query.getResultList(); for (ResourceConfigurationUpdate request : requests) { // TODO [mazz]: should we make this configurable? long timeout = 1000L * 60 * 10; // 10 minutes - should be more than enough time long duration = request.getDuration(); if (duration > timeout) { LOG.info("Resource configuration update request seems to have been orphaned - timing it out: " + request); request.setErrorMessage("Timed out - did not complete after " + duration + " ms" + " (the timeout period was " + timeout + " ms)"); request.setStatus(ConfigurationUpdateStatus.FAILURE); // If it's part of a group update, check if all member updates of the group update have completed, // and, if so, update the group update's status. checkForCompletedGroupResourceConfigurationUpdate(request.getId()); } } } catch (Throwable t) { LOG.error("Failed to check for timed out Resource configuration update requests. Cause: " + t); } }
current = (ResourceConfigurationUpdate) result; if (ConfigurationUpdateStatus.INPROGRESS == current.getStatus()) { Configuration currentConfiguration = current.getConfiguration(); Hibernate.initialize(currentConfiguration.getMap()); if (currentConfiguration.equals(newConfiguration)) { resource = current.getResource(); ResourceConfigurationUpdate newUpdateRequest = new ResourceConfigurationUpdate(resource, zeroedConfiguration, newSubject); newUpdateRequest.setStatus(newStatus); newUpdateRequest.setErrorMessage(errorMessage);
Configuration failedConfiguration = response.getConfiguration(); update.setConfiguration(failedConfiguration); Resource resource = update.getResource(); resource.setResourceConfiguration(update.getConfiguration().deepCopyWithoutProxies()); notifyAlertConditionCacheManager("completeResourceConfigurationUpdate", update); update.setStatus(response.getStatus()); update.setErrorMessage(response.getErrorMessage());
@Override public void rollbackResourceConfiguration(Subject subject, int resourceId, int configHistoryId) throws ConfigurationUpdateException { ResourceConfigurationUpdate configurationUpdateHistory = entityManager.find(ResourceConfigurationUpdate.class, configHistoryId); Configuration configuration = configurationUpdateHistory.getConfiguration(); if (configuration == null) { throw new ConfigurationUpdateException("No configuration history element exists with id = '" + configHistoryId + "'"); } if (isStructuredAndRawSupported(resourceId)) { updateStructuredOrRawConfiguration(subject, resourceId, configuration, false); } else { updateResourceConfiguration(subject, resourceId, configuration); } }
public AlertConditionCacheStats checkConditions(ResourceConfigurationUpdate update) { if (update == null) { return new AlertConditionCacheStats(); } AlertConditionCacheStats stats = new AlertConditionCacheStats(); try { Resource resource = update.getResource(); List<ResourceConfigurationCacheElement> cacheElements = lookupResourceConfigurationCacheElements(resource .getId()); processCacheElements(cacheElements, update.getConfiguration(), update.getCreatedTime(), stats); AlertConditionCacheMonitor.getMBean().incrementResourceConfigurationCacheElementMatches(stats.matched); AlertConditionCacheMonitor.getMBean().incrementResourceConfigurationProcessingTime(stats.getAge()); if (log.isDebugEnabled()) log.debug("Check " + update + " - " + stats); } catch (Throwable t) { // don't let any exceptions bubble up to the calling SLSB layer log.error("Error during global cache processing: ", t); } return stats; }
query.setParameter("resourceId", resourceId); current = (ResourceConfigurationUpdate) query.getSingleResult(); resource = current.getResource(); } catch (NoResultException nre) { query.setParameter("resourceId", resourceId); latest = (ResourceConfigurationUpdate) query.getSingleResult(); if (latest.getStatus() == ConfigurationUpdateStatus.INPROGRESS) { Configuration configuration = current.getConfiguration(); configuration.getMap().size(); ConfigurationDefinition configurationDefinition = getResourceConfigurationDefinitionForResourceType( Configuration currentConfig = (current != null) ? current.getConfiguration() : null; Configuration configuration = current.getConfiguration(); configuration.getMap().size(); ConfigurationDefinition configurationDefinition = getResourceConfigurationDefinitionForResourceType(
/** * @deprecated use criteria-based API */ @Deprecated @Override public ResourceConfigurationUpdate getResourceConfigurationUpdate(Subject subject, int configurationUpdateId) { ResourceConfigurationUpdate update = entityManager.find(ResourceConfigurationUpdate.class, configurationUpdateId); if (!authorizationManager.canViewResource(subject, update.getResource().getId())) { throw new PermissionException("User [" + subject.getName() + "] does not have permission to view resource configuration update for [" + update.getResource() + "]"); } update.getConfiguration(); // this is EAGER loaded, so this really doesn't do anything return update; }
@Override public void executeResourceConfigurationUpdate(int updateId) { ResourceConfigurationUpdate update = getResourceConfigurationUpdate(subjectManager.getOverlord(), updateId); Configuration originalConfig = update.getConfiguration(); update.setConfiguration(originalConfig.deepCopy(false)); executeResourceConfigurationUpdate(update); }
ResourceConfigurationUpdate resourceConfigUpdate = entityManager.find(ResourceConfigurationUpdate.class, resourceConfigUpdateId); if (resourceConfigUpdate.getStatus() == ConfigurationUpdateStatus.INPROGRESS) { GroupResourceConfigurationUpdate groupConfigUpdate = resourceConfigUpdate.getGroupConfigurationUpdate(); if (groupConfigUpdate == null) {
if (null != invalidConfig) { Resource resource = resourceManager.getResourceById(subject, resourceId); ResourceConfigurationUpdate resourceConfigurationUpdate = new ResourceConfigurationUpdate(resource, invalidConfig, subject.getName()); resourceConfigurationUpdate.setErrorMessage("resource.validation.failed"); resourceConfigurationUpdate.setStatus(ConfigurationUpdateStatus.FAILURE); ResourceConfigurationUpdate resourceConfigurationUpdate = new ResourceConfigurationUpdate(resource, newConfiguration, subject.getName()); resourceConfigurationUpdate.setErrorMessage(e.getMessage()); resourceConfigurationUpdate.setStatus(ConfigurationUpdateStatus.FAILURE); return resourceConfigurationUpdate;
@Override public boolean isResourceConfigurationUpdateInProgress(Subject subject, int resourceId) { boolean updateInProgress; try { Query query = entityManager.createNamedQuery(ResourceConfigurationUpdate.QUERY_FIND_LATEST_BY_RESOURCE_ID); query.setParameter("resourceId", resourceId); ResourceConfigurationUpdate latestConfigUpdate = (ResourceConfigurationUpdate) query.getSingleResult(); if (!authorizationManager.hasResourcePermission(subject, Permission.CONFIGURE_READ, latestConfigUpdate .getResource().getId())) { throw new PermissionException("User [" + subject.getName() + "] does not have permission to view Resource configuration for [" + latestConfigUpdate.getResource() + "]"); } updateInProgress = (latestConfigUpdate.getStatus() == ConfigurationUpdateStatus.INPROGRESS); } catch (NoResultException nre) { // The resource config history is empty, so there's obviously no update in progress. updateInProgress = false; } return updateInProgress; }
ConfigurationMaskingUtility.unmaskConfiguration(memberResourceConfiguration, existingResourceConfiguration); Resource flyWeight = new Resource(resourceId); ResourceConfigurationUpdate memberUpdate = new ResourceConfigurationUpdate(flyWeight, memberResourceConfiguration, subject.getName()); memberUpdate.setGroupConfigurationUpdate(groupUpdate); entityManager.persist(memberUpdate);
private boolean waitForConfigurationUpdateToFinish(Subject subject, ResourceConfigurationUpdateCriteria criteria, int maxAttempts) { if (maxAttempts == 0) return false; PageList<ResourceConfigurationUpdate> configUpdates = configurationManager .findResourceConfigurationUpdatesByCriteria(subject, criteria); switch (configUpdates.get(0).getStatus()) { case INPROGRESS: // try it again in 2.5 sec break; case FAILURE: return false; default: return true; } try { Thread.sleep(2500L); } catch (InterruptedException e) { return false; } return waitForConfigurationUpdateToFinish(subject, criteria, maxAttempts - 1); }
criteria.addFilterId(resourceUpdate.getId()); criteria.addFilterStartTime(System.currentTimeMillis() - (5 * 60 * 1000)); boolean updateSuccess = waitForConfigurationUpdateToFinish(subject, criteria, 10);
public Configuration getResourceConfiguration() { if (!LazyLoadScenario.isShouldLoad()) return null; //make sure to fetch the latest known resource config. This ensures that //the server goes out to the agent if there is no known config yet and thus //giving the scripting user an always up-to-date info. ResourceConfigurationUpdate update = remoteClient.getProxy(ConfigurationManagerRemote.class) .getLatestResourceConfigurationUpdate(remoteClient.getSubject(), resourceClientProxy.resourceId); return update == null ? null : update.getConfiguration(); }
@Override public PageList<ResourceConfigurationUpdate> findResourceConfigurationUpdatesByCriteria(Subject subject, ResourceConfigurationUpdateCriteria criteria) { CriteriaQueryGenerator generator = new CriteriaQueryGenerator(subject, criteria); if (!authorizationManager.isInventoryManager(subject)) { generator.setAuthorizationResourceFragment(CriteriaQueryGenerator.AuthorizationTokenType.RESOURCE, "resource", subject.getId()); } CriteriaQueryRunner<ResourceConfigurationUpdate> queryRunner = new CriteriaQueryRunner<ResourceConfigurationUpdate>( criteria, generator, entityManager); PageList<ResourceConfigurationUpdate> updates = queryRunner.execute(); // If configurations were fetched, mask them before returning the updates. // We do not want the masked configurations persisted, so detach all entities before masking the configurations. Set<String> fetchFields = new HashSet<String>(generator.getFetchFields(criteria)); if (fetchFields.contains(AbstractConfigurationUpdateCriteria.FETCH_FIELD_CONFIGURATION)) { for (ResourceConfigurationUpdate update : updates) { Configuration configuration = update.getConfiguration(); configuration.getMap().size(); } entityManager.clear(); for (ResourceConfigurationUpdate update : updates) { Configuration configuration = update.getConfiguration(); ConfigurationDefinition configurationDefinition = getResourceConfigurationDefinitionForResourceType( subjectManager.getOverlord(), update.getResource().getResourceType().getId()); ConfigurationMaskingUtility.maskConfiguration(configuration, configurationDefinition); } } return updates; }