Java tutorial
/** * Copyright (C) 2011 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.web.server; import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.Executors; import java.util.concurrent.locks.ReentrantLock; import org.apache.commons.lang.StringUtils; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.opengamma.OpenGammaRuntimeException; import com.opengamma.core.config.ConfigSource; import com.opengamma.core.config.impl.ConfigItem; import com.opengamma.core.position.Portfolio; import com.opengamma.core.position.PositionSource; import com.opengamma.core.security.SecuritySource; import com.opengamma.engine.view.ViewDefinition; import com.opengamma.engine.view.compilation.PortfolioCompiler; import com.opengamma.financial.aggregation.AggregationFunction; import com.opengamma.financial.aggregation.PortfolioAggregator; import com.opengamma.financial.portfolio.save.SavePortfolio; import com.opengamma.id.UniqueId; import com.opengamma.id.VersionCorrection; import com.opengamma.master.config.ConfigDocument; import com.opengamma.master.config.ConfigMaster; import com.opengamma.master.portfolio.PortfolioMaster; import com.opengamma.master.position.PositionMaster; import com.opengamma.util.ArgumentChecker; import com.opengamma.util.tuple.Pair; /** * Manages the lifecycle of aggregated view definitions. There is really no such thing as an aggregated view * definition, only an aggregated portfolio, but the web client exposes the idea of aggregating a view definition as a * shortcut for aggregating the underlying portfolio and requesting the same outputs. */ public class AggregatedViewDefinitionManager { private final PositionSource _positionSource; private final SecuritySource _securitySource; private final ConfigSource _combinedConfigSource; private final ConfigMaster _userConfigMaster; private final PortfolioMaster _userPortfolioMaster; private final Map<String, AggregationFunction<?>> _portfolioAggregators; private final SavePortfolio _portfolioSaver; private final ReentrantLock _lock = new ReentrantLock(); private final Map<Pair<UniqueId, List<String>>, PortfolioReference> _aggregatedPortfolios = Maps.newHashMap(); private final Map<Pair<UniqueId, List<String>>, ViewDefinitionReference> _aggregatedViewDefinitions = Maps .newHashMap(); public AggregatedViewDefinitionManager(PositionSource positionSource, SecuritySource securitySource, ConfigSource combinedConfigSource, ConfigMaster userConfigMaster, PortfolioMaster userPortfolioMaster, PositionMaster userPositionMaster, Map<String, AggregationFunction<?>> portfolioAggregators) { _positionSource = positionSource; _securitySource = securitySource; _combinedConfigSource = combinedConfigSource; _userConfigMaster = userConfigMaster; _userPortfolioMaster = userPortfolioMaster; _portfolioAggregators = portfolioAggregators; _portfolioSaver = new SavePortfolio(Executors.newSingleThreadExecutor(), userPortfolioMaster, userPositionMaster); } public Set<String> getAggregatorNames() { return ImmutableSet.copyOf(_portfolioAggregators.keySet()); } public UniqueId getViewDefinitionId(UniqueId baseViewDefinitionId, String aggregatorName) { List<String> aggregators; if (aggregatorName != null) { aggregators = Collections.singletonList(aggregatorName); } else { aggregators = Collections.emptyList(); } return getViewDefinitionId(baseViewDefinitionId, aggregators); } public UniqueId getViewDefinitionId(UniqueId baseViewDefinitionId, List<String> aggregatorNames) { // TODO: what about changes to the base view definition? ArgumentChecker.notNull(baseViewDefinitionId, "baseViewDefinitionId"); ArgumentChecker.notNull(aggregatorNames, "aggregatorNames"); ViewDefinition baseViewDefinition = (ViewDefinition) _combinedConfigSource.get(baseViewDefinitionId) .getValue(); if (baseViewDefinition == null) { throw new OpenGammaRuntimeException("Unknown view definition with unique ID " + baseViewDefinitionId); } UniqueId basePortfolioId = baseViewDefinition.getPortfolioId(); if (aggregatorNames.isEmpty() || basePortfolioId == null) { return baseViewDefinitionId; } Pair<UniqueId, List<String>> aggregatedViewDefinitionKey = Pair.of(baseViewDefinition.getUniqueId(), aggregatorNames); Pair<UniqueId, List<String>> aggregatedPortfolioKey = Pair.of(basePortfolioId, aggregatorNames); _lock.lock(); try { ViewDefinitionReference aggregatedViewDefinitionReference = _aggregatedViewDefinitions .get(aggregatedViewDefinitionKey); if (aggregatedViewDefinitionReference == null) { PortfolioReference aggregatedPortfolioReference = _aggregatedPortfolios.get(aggregatedPortfolioKey); if (aggregatedPortfolioReference == null) { UniqueId aggregatedPortfolioId = aggregatePortfolio(basePortfolioId, aggregatorNames); aggregatedPortfolioReference = new PortfolioReference(basePortfolioId, aggregatedPortfolioId); _aggregatedPortfolios.put(aggregatedPortfolioKey, aggregatedPortfolioReference); } String aggregatedViewDefinitionName = getAggregatedViewDefinitionName(baseViewDefinition.getName(), aggregatorNames); ViewDefinition aggregatedViewDefinition = baseViewDefinition.copyWith(aggregatedViewDefinitionName, aggregatedPortfolioReference.incrementReferenceCount(), baseViewDefinition.getMarketDataUser()); // Treat as a transient view definition that should not be persistent //aggregatedViewDefinition.setPersistent(false); ConfigItem<ViewDefinition> configItem = ConfigItem.of(aggregatedViewDefinition); configItem.setName(aggregatedViewDefinition.getName()); UniqueId viewDefinitionId = _userConfigMaster.add(new ConfigDocument(configItem)).getUniqueId(); aggregatedViewDefinitionReference = new ViewDefinitionReference(viewDefinitionId, aggregatedPortfolioReference); _aggregatedViewDefinitions.put(aggregatedViewDefinitionKey, aggregatedViewDefinitionReference); } return aggregatedViewDefinitionReference.incrementReferenceCount(); } finally { _lock.unlock(); } } public void releaseViewDefinition(UniqueId baseViewDefinitionId, String aggregatorName) { List<String> aggregatorNames; if (aggregatorName != null) { aggregatorNames = Collections.singletonList(aggregatorName); } else { aggregatorNames = Collections.emptyList(); } releaseViewDefinition(baseViewDefinitionId, aggregatorNames); } public void releaseViewDefinition(UniqueId baseViewDefinitionId, List<String> aggregatorNames) { Pair<UniqueId, List<String>> aggregatedViewDefinitionKey = Pair.of(baseViewDefinitionId, aggregatorNames); ViewDefinitionReference viewDefinitionReference = _aggregatedViewDefinitions .get(aggregatedViewDefinitionKey); if (viewDefinitionReference == null) { return; } _lock.lock(); try { if (viewDefinitionReference.decrementReferenceCount() <= 0) { PortfolioReference portfolioReference = viewDefinitionReference.getPortfolioReference(); if (portfolioReference.decrementReferenceCount() <= 0) { _userPortfolioMaster.remove(portfolioReference.getPortfolioId()); Pair<UniqueId, List<String>> aggregatedPortfolioKey = Pair .of(portfolioReference.getBasePortfolioId(), aggregatorNames); _aggregatedPortfolios.remove(aggregatedPortfolioKey); } _userConfigMaster.remove(viewDefinitionReference.getViewDefinitionId()); _aggregatedViewDefinitions.remove(aggregatedViewDefinitionKey); } } finally { _lock.unlock(); } } private String getAggregatedViewDefinitionName(String baseViewDefinitionName, List<String> aggregatorNames) { return baseViewDefinitionName + " aggregated by " + StringUtils.join(aggregatorNames, ", "); } private UniqueId aggregatePortfolio(UniqueId basePortfolioId, List<String> aggregatorNames) { // REVIEW jonathan 2011-11-13 -- portfolio aggregation is currently painful. The positions obtained from the // position source during the orginal portfolio lookup contain munged identifiers that do not correspond to // anything in the position master. We end up rewriting the positions even though there is no need, then we cannot // clean them up when the portfolio is no longer required in case other portfolios have now referenced the new // positions. Portfolio basePortfolio = _positionSource.getPortfolio(basePortfolioId, VersionCorrection.LATEST); Portfolio resolvedPortfolio = PortfolioCompiler.resolvePortfolio(basePortfolio, Executors.newSingleThreadExecutor(), _securitySource); List<AggregationFunction<?>> aggregationFunctions = Lists.newArrayListWithCapacity(aggregatorNames.size()); for (String aggregatorName : aggregatorNames) { AggregationFunction<?> aggregationFunction = _portfolioAggregators.get(aggregatorName); if (aggregationFunction == null) { throw new OpenGammaRuntimeException("Unknown aggregator '" + aggregatorName + "'"); } aggregationFunctions.add(aggregationFunction); } PortfolioAggregator aggregator = new PortfolioAggregator(aggregationFunctions); Portfolio aggregatedPortfolio = aggregator.aggregate(resolvedPortfolio); return _portfolioSaver.savePortfolio(aggregatedPortfolio, false); } //------------------------------------------------------------------------- private static class PortfolioReference { private final UniqueId _basePortfolioId; private final UniqueId _portfolioId; private long _referenceCount; public PortfolioReference(UniqueId basePortfolioId, UniqueId portfolioId) { _basePortfolioId = basePortfolioId; _portfolioId = portfolioId; } public UniqueId getBasePortfolioId() { return _basePortfolioId; } public UniqueId getPortfolioId() { return _portfolioId; } public UniqueId incrementReferenceCount() { _referenceCount++; return _portfolioId; } public long decrementReferenceCount() { return --_referenceCount; } } private static class ViewDefinitionReference { private final UniqueId _viewDefinitionId; private final PortfolioReference _portfolioReference; private long _referenceCount; public ViewDefinitionReference(UniqueId viewDefinitionId, PortfolioReference portfolioReference) { _viewDefinitionId = viewDefinitionId; _portfolioReference = portfolioReference; } public UniqueId getViewDefinitionId() { return _viewDefinitionId; } public PortfolioReference getPortfolioReference() { return _portfolioReference; } public UniqueId incrementReferenceCount() { _referenceCount++; return _viewDefinitionId; } public long decrementReferenceCount() { return --_referenceCount; } } }