ViewStatusCalculationTask.java example

Explorer
OG-Platform-master
- projects
- sesame
/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.integration.viewer.status.impl;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.threeten.bp.Instant;

import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.opengamma.OpenGammaRuntimeException;
import com.opengamma.core.config.impl.ConfigItem;
import com.opengamma.core.position.Portfolio;
import com.opengamma.core.position.Position;
import com.opengamma.core.position.PositionSource;
import com.opengamma.core.position.Trade;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.calcnode.MissingValue;
import com.opengamma.engine.marketdata.spec.MarketDataSpecification;
import com.opengamma.engine.target.ComputationTargetType;
import com.opengamma.engine.value.ComputedValueResult;
import com.opengamma.engine.value.ValueProperties;
import com.opengamma.engine.value.ValueRequirement;
import com.opengamma.engine.value.ValueSpecification;
import com.opengamma.engine.view.ViewCalculationConfiguration;
import com.opengamma.engine.view.ViewCalculationResultModel;
import com.opengamma.engine.view.ViewComputationResultModel;
import com.opengamma.engine.view.ViewDefinition;
import com.opengamma.engine.view.ViewDeltaResultModel;
import com.opengamma.engine.view.ViewProcessor;
import com.opengamma.engine.view.client.ViewClient;
import com.opengamma.engine.view.compilation.CompiledViewCalculationConfiguration;
import com.opengamma.engine.view.compilation.CompiledViewDefinition;
import com.opengamma.engine.view.cycle.ViewCycleMetadata;
import com.opengamma.engine.view.execution.ExecutionOptions;
import com.opengamma.engine.view.execution.ViewCycleExecutionOptions;
import com.opengamma.engine.view.listener.AbstractViewResultListener;
import com.opengamma.financial.aggregation.CurrenciesAggregationFunction;
import com.opengamma.financial.aggregation.PortfolioAggregator;
import com.opengamma.financial.tool.ToolContext;
import com.opengamma.id.UniqueId;
import com.opengamma.id.VersionCorrection;
import com.opengamma.integration.viewer.status.ViewStatus;
import com.opengamma.livedata.UserPrincipal;
import com.opengamma.master.config.ConfigMaster;
import com.opengamma.master.config.ConfigMasterUtils;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.GUIDGenerator;
import com.opengamma.util.tuple.Pair;

/**
 * View status calculation task
 */
public class ViewStatusCalculationTask implements Callable<PerViewStatusResult> {
  
  private final class ViewStatusResultListener extends AbstractViewResultListener {
    private final CountDownLatch _latch;
    private final PerViewStatusResult _statusResult;
    private final ViewDefinition _viewDefinition;
    private AtomicLong _count = new AtomicLong(0);

    private ViewStatusResultListener(CountDownLatch latch, PerViewStatusResult statusResult, ViewDefinition viewDefinition) {
      _latch = latch;
      _statusResult = statusResult;
      _viewDefinition = viewDefinition;
    }

    @Override
    public UserPrincipal getUser() {
      return _user;
    }

    @Override
    public void viewDefinitionCompiled(CompiledViewDefinition compiledViewDefinition, boolean hasMarketDataPermissions) {
      s_logger.error("View definition compiled");
      CompiledViewCalculationConfiguration compiledCalculationConfiguration = compiledViewDefinition.getCompiledCalculationConfiguration(DEFAULT_CALC_CONFIG);
      Map<ValueSpecification, Set<ValueRequirement>> terminalOutputs = compiledCalculationConfiguration.getTerminalOutputSpecifications();
      for (ValueSpecification valueSpec : terminalOutputs.keySet()) {
        ComputationTargetType computationTargetType = valueSpec.getTargetSpecification().getType();
        if (isValidTargetType(computationTargetType)) {
          UniqueId uniqueId = valueSpec.getTargetSpecification().getUniqueId();
          String currency = getCurrency(uniqueId, computationTargetType);
          if (currency != null) {
            _statusResult.put(new ViewStatusKeyBean(_securityType, valueSpec.getValueName(), currency, computationTargetType.getName()), ViewStatus.NO_VALUE);
          } else {
            s_logger.error("Discarding result as NULL return as Currency for id: {} targetType:{}", uniqueId, computationTargetType);
          }
        }
      }
    }

    @Override
    public void viewDefinitionCompilationFailed(final Instant valuationTime, final Exception exception) {
      s_logger.debug("View definition {} failed to initialize", _viewDefinition);
      try {
        processGraphFailResult(_statusResult);
      } finally {
        _latch.countDown();
      }
    }

    public void cycleStarted(ViewCycleMetadata cycleInfo) {
      s_logger.debug("Cycle started");
    }

    @Override
    public void cycleExecutionFailed(ViewCycleExecutionOptions executionOptions, Exception exception) {
      s_logger.debug("Cycle execution failed", exception);
    }

    @Override
    public void processCompleted() {
      s_logger.debug("Process completed");
    }

    @Override
    public void processTerminated(boolean executionInterrupted) {
      s_logger.debug("Process terminated");
    }

    @Override
    public void clientShutdown(Exception e) {
      s_logger.debug("Client shutdown");
    }

    @Override
    public void cycleFragmentCompleted(ViewComputationResultModel fullResult, ViewDeltaResultModel deltaResult) {
      s_logger.debug("cycle fragment completed");
    }

    @Override
    public void cycleCompleted(final ViewComputationResultModel fullResult, final ViewDeltaResultModel deltaResult) {
      s_logger.debug("cycle {} completed", _count.get());
      if (_count.getAndIncrement() > 5) {
        processStatusResult(fullResult, _statusResult);
        _latch.countDown();
      }
    }
  }

  private static final String MIXED_CURRENCY = "MIXED_CURRENCY";
  private static final Logger s_logger = LoggerFactory.getLogger(ViewStatusCalculationTask.class);
  
  private static final String DEFAULT_CALC_CONFIG = "Default";
  
  private final String _securityType;
  private final Set<String> _valueRequirementNames;
  private final UniqueId _portfolioId;
  private final UserPrincipal _user;
  private final ToolContext _toolContext;
  private final CurrenciesAggregationFunction _currenciesAggrFunction;
  private final Map<UniqueId, String> _targetCurrenciesCache = Maps.newConcurrentMap();
  private final MarketDataSpecification _marketDataSpecification;
  
  public ViewStatusCalculationTask(ToolContext toolcontext, UniqueId portfolioId, UserPrincipal user, String securityType, 
      Collection<String> valueRequirementNames, MarketDataSpecification marketDataSpecification) {
    ArgumentChecker.notNull(portfolioId, "portfolioId");
    ArgumentChecker.notNull(securityType, "securityType");
    ArgumentChecker.notNull(valueRequirementNames, "valueRequirementNames");
    ArgumentChecker.notNull(user, "user");
    ArgumentChecker.notNull(toolcontext, "toolcontext");
    ArgumentChecker.notNull(marketDataSpecification, "marketDataSpecification");
    
    _portfolioId = portfolioId;
    _user = user;
    _securityType = securityType;
    _valueRequirementNames = ImmutableSet.copyOf(valueRequirementNames);
    _toolContext = toolcontext;
    _currenciesAggrFunction = new CurrenciesAggregationFunction(_toolContext.getSecuritySource());
    _marketDataSpecification = marketDataSpecification;
  }

  @Override
  public PerViewStatusResult call() throws Exception {
    s_logger.debug("Start calculating result for security:{} with values{}", _securityType, Sets.newTreeSet(_valueRequirementNames).toString());
    
    final PerViewStatusResult statusResult = new PerViewStatusResult(_securityType);
    //No need to do any work if there are no ValueRequirements to compute
    if (_valueRequirementNames.isEmpty()) {
      return statusResult;
    }
    final ViewDefinition viewDefinition = createViewDefinition();
    final ViewProcessor viewProcessor = _toolContext.getViewProcessor();
    final ViewClient client = viewProcessor.createViewClient(_user);

    final CountDownLatch latch = new CountDownLatch(1);
    client.setResultListener(new ViewStatusResultListener(latch, statusResult, viewDefinition));
    client.attachToViewProcess(viewDefinition.getUniqueId(), ExecutionOptions.infinite(_marketDataSpecification));
   
    try {
      s_logger.info("main thread waiting");
      if (!latch.await(30, TimeUnit.SECONDS)) {
        s_logger.error("Timed out waiting for {}", viewDefinition);
      }
    } catch (final InterruptedException ex) {
      throw new OpenGammaRuntimeException("Interrupted while waiting for " + viewDefinition, ex);
    }
    client.detachFromViewProcess();
    removeViewDefinition(viewDefinition);
    s_logger.debug("PerViewStatusResult for securityType:{} is {}", _securityType, statusResult);
    return statusResult;
  }

  

  protected boolean isValidTargetType(final ComputationTargetType computationTargetType) {
    if (ComputationTargetType.POSITION.isCompatible(computationTargetType) || ComputationTargetType.PORTFOLIO.isCompatible(computationTargetType) ||
        ComputationTargetType.PORTFOLIO_NODE.isCompatible(computationTargetType) || ComputationTargetType.TRADE.isCompatible(computationTargetType)) {
      return true;
    }
    return false;
  }

  private void removeViewDefinition(ViewDefinition viewDefinition) {
    s_logger.debug("Removing ViewDefintion with id: {}", viewDefinition.getUniqueId());
    ConfigMaster configMaster = _toolContext.getConfigMaster();
    configMaster.remove(viewDefinition.getUniqueId().getObjectId());
    s_logger.debug("ViewDefinition {} removed", viewDefinition.getUniqueId());
  }

  private ViewDefinition createViewDefinition() {
    final ViewDefinition viewDefinition = new ViewDefinition("VS_VIEW_" + GUIDGenerator.generate().toString(), _portfolioId, _user);
    viewDefinition.setMaxDeltaCalculationPeriod(500L);
    viewDefinition.setMaxFullCalculationPeriod(500L);
    viewDefinition.setMinDeltaCalculationPeriod(500L);
    viewDefinition.setMinFullCalculationPeriod(500L);

    ViewCalculationConfiguration defaultCalConfig = new ViewCalculationConfiguration(viewDefinition, DEFAULT_CALC_CONFIG);
    for (String requiredOutput : _valueRequirementNames) {
      defaultCalConfig.addPortfolioRequirementName(_securityType, requiredOutput);
    }
    viewDefinition.addViewCalculationConfiguration(defaultCalConfig);
    return storeViewDefinition(viewDefinition);
  }
  
  private ViewDefinition storeViewDefinition(final ViewDefinition viewDefinition) {
    ConfigItem<ViewDefinition> config = ConfigItem.of(viewDefinition, viewDefinition.getName(), ViewDefinition.class);
    config = ConfigMasterUtils.storeByName(_toolContext.getConfigMaster(), config);
    return config.getValue();
  }
  
  private void processGraphFailResult(final PerViewStatusResult statusResult) {
    PositionSource positionSource = _toolContext.getPositionSource();
    Portfolio portfolio = positionSource.getPortfolio(_portfolioId, VersionCorrection.LATEST);
    List<Position> positions = PortfolioAggregator.flatten(portfolio);
    Set<String> currencies = Sets.newHashSet();
    for (Position position : positions) {
      if (position.getSecurity() == null) {
        position.getSecurityLink().resolve(_toolContext.getSecuritySource());
      }
      if (position.getSecurity() != null && _securityType.equals(position.getSecurity().getSecurityType())) {
        currencies.add(getCurrency(position.getUniqueId(), ComputationTargetType.POSITION));
      }
    }
    for (String valueName : _valueRequirementNames) {
      for (String currency : currencies) {
        statusResult.put(new ViewStatusKeyBean(_securityType, valueName, currency, ComputationTargetType.POSITION.getName()), ViewStatus.GRAPH_FAIL);
      }
    }
  }
  
  private void processStatusResult(ViewComputationResultModel fullResult, PerViewStatusResult statusResult) {
    ViewCalculationResultModel calculationResult = fullResult.getCalculationResult(DEFAULT_CALC_CONFIG);
    Collection<ComputationTargetSpecification> allTargets = calculationResult.getAllTargets();
    for (ComputationTargetSpecification targetSpec : allTargets) {
      ComputationTargetType targetType = targetSpec.getSpecification().getType();
      if (isValidTargetType(targetType)) {
        Map<Pair<String, ValueProperties>, ComputedValueResult> values = calculationResult.getValues(targetSpec);
        for (Map.Entry<Pair<String, ValueProperties>, ComputedValueResult> valueEntry : values.entrySet()) {
          String valueName = valueEntry.getKey().getFirst();
          String currency = getCurrency(targetSpec.getUniqueId(), targetType);
          s_logger.debug("{} currency returned for id:{} targetType:{}", currency, targetSpec.getUniqueId(), targetType);
          if (currency != null) {
            ComputedValueResult computedValue = valueEntry.getValue();
            if (isGoodValue(computedValue)) {
              statusResult.put(new ViewStatusKeyBean(_securityType, valueName, currency, targetType.getName()), ViewStatus.VALUE);
            }
          } else {
            s_logger.error("Discarding result as NULL return as Currency for id: {} targetType:{}", targetSpec.getUniqueId(), targetType);
          }
        }
      }
    }
  }
  
  private String getCurrency(UniqueId uniqueId, ComputationTargetType computationTargetType) {
    synchronized (_targetCurrenciesCache) {
      String currency = _targetCurrenciesCache.get(uniqueId);
      if (currency == null) {
        if (ComputationTargetType.PORTFOLIO_NODE.isCompatible(computationTargetType) || ComputationTargetType.PORTFOLIO.isCompatible(computationTargetType)) {
          currency = MIXED_CURRENCY;
        } else if (ComputationTargetType.POSITION.isCompatible(computationTargetType)) {
          PositionSource positionSource = _toolContext.getPositionSource();
          Position position = positionSource.getPosition(uniqueId);
          if (position.getSecurity() == null) {
            position.getSecurityLink().resolve(_toolContext.getSecuritySource());
          }
          if (position.getSecurity() != null) {
            currency = _currenciesAggrFunction.classifyPosition(position);
          } 
        } else if (ComputationTargetType.TRADE.isCompatible(computationTargetType)) {
          PositionSource positionSource = _toolContext.getPositionSource();
          Trade trade = positionSource.getTrade(uniqueId);
          if (trade.getSecurity() == null) {
            trade.getSecurityLink().resolve(_toolContext.getSecuritySource());
          }
          if (trade.getSecurity() != null) {
            currency = CurrenciesAggregationFunction.classifyBasedOnSecurity(trade.getSecurity(), _toolContext.getSecuritySource());
          }
        }
      }
      if (currency == null) {
        currency = CurrenciesAggregationFunction.NO_CURRENCY;
      }
      _targetCurrenciesCache.put(uniqueId, currency);
      return currency;
    }
  }
  
  private boolean isGoodValue(final ComputedValueResult computedValue) {
    if (computedValue == null || computedValue.getValue() == null || StringUtils.EMPTY.equals(computedValue.getValue())) {
      return false;
    } else {
      return !(computedValue.getValue() instanceof MissingValue);
    }
  }
  
}