Java tutorial
/** * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies * * Please see distribution for license. */ package com.opengamma.financial.generator; import java.security.SecureRandom; import java.util.Random; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.Option; import org.apache.commons.cli.OptionBuilder; import org.apache.commons.cli.Options; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.opengamma.OpenGammaRuntimeException; import com.opengamma.core.position.Portfolio; import com.opengamma.core.position.PortfolioNode; import com.opengamma.core.position.Position; import com.opengamma.core.position.Trade; import com.opengamma.core.security.Security; import com.opengamma.core.security.SecuritySource; import com.opengamma.financial.tool.ToolContext; import com.opengamma.master.portfolio.ManageablePortfolio; import com.opengamma.master.portfolio.ManageablePortfolioNode; import com.opengamma.master.portfolio.PortfolioDocument; import com.opengamma.master.portfolio.PortfolioSearchRequest; import com.opengamma.master.portfolio.PortfolioSearchResult; import com.opengamma.master.position.ManageablePosition; import com.opengamma.master.position.ManageableTrade; import com.opengamma.master.position.PositionDocument; import com.opengamma.master.position.PositionMaster; import com.opengamma.master.security.ManageableSecurityLink; import com.opengamma.util.money.Currency; /** * Utility for generating a portfolio of securities. */ public abstract class AbstractPortfolioGeneratorTool { private static final Logger s_logger = LoggerFactory.getLogger(AbstractPortfolioGeneratorTool.class); /** * Default counter party name */ public static final String DEFAULT_COUNTER_PARTY = "COUNTERPARTY"; /** * Default portfolio size used by sub-classes. */ protected static final int PORTFOLIO_SIZE = 200; private Random _random; private SecurityPersister _securityPersister; private ToolContext _toolContext; private Class<? extends AbstractPortfolioGeneratorTool> _classContext; private AbstractPortfolioGeneratorTool _objectContext; private NameGenerator _counterPartyGenerator; private Currency[] _currencies; public AbstractPortfolioGeneratorTool() { _classContext = getClass(); } public PortfolioGenerator createPortfolioGenerator(final NameGenerator portfolioNameGenerator) { return new PortfolioGenerator(createPortfolioNodeGenerator(PORTFOLIO_SIZE), portfolioNameGenerator); } public Portfolio createPortfolio(final String portfolioName) { return createPortfolioGenerator(new StaticNameGenerator(portfolioName)).createPortfolio(); } public PortfolioNodeGenerator createPortfolioNodeGenerator(final int portfolioSize) { throw new UnsupportedOperationException(); } public PortfolioNode createPortfolioNode(final int size) { return createPortfolioNodeGenerator(size).createPortfolioNode(); } public PortfolioNode createPortfolioNode() { return createPortfolioNode(PORTFOLIO_SIZE); } public Random getRandom() { return _random; } public void setRandom(final Random random) { _random = random; } public Currency[] getCurrencies() { return _currencies; } public void setCurrencies(final Currency[] currencies) { _currencies = currencies; } private void setContext(final Class<? extends AbstractPortfolioGeneratorTool> classContext, final AbstractPortfolioGeneratorTool objectContext) { _classContext = classContext; _objectContext = objectContext; } private Class<? extends AbstractPortfolioGeneratorTool> getClassContext() { return _classContext; } private AbstractPortfolioGeneratorTool getObjectContext() { return _objectContext; } public SecurityPersister getSecurityPersister() { return _securityPersister; } public void setSecurityPersister(final SecurityPersister securityPersister) { _securityPersister = securityPersister; } public NameGenerator getCounterPartyGenerator() { return _counterPartyGenerator; } public void setCounterPartyGenerator(final NameGenerator counterPartyGenerator) { _counterPartyGenerator = counterPartyGenerator; } public ToolContext getToolContext() { return _toolContext; } public void setToolContext(final ToolContext toolContext) { _toolContext = toolContext; } protected final void configure(final SecurityGenerator<?> securityGenerator) { if (getRandom() != null) { securityGenerator.setRandom(getRandom()); } if (getCurrencies() != null && getCurrencies().length > 0) { securityGenerator.setCurrencies(getCurrencies()); } if (getToolContext() != null) { securityGenerator.setConfigSource(getToolContext().getConfigSource()); securityGenerator.setConventionSource(getToolContext().getConventionSource()); securityGenerator.setConventionBundleSource(getToolContext().getConventionBundleSource()); securityGenerator.setHolidaySource(getToolContext().getHolidaySource()); securityGenerator.setHistoricalSource(getToolContext().getHistoricalTimeSeriesSource()); securityGenerator.setExchangeMaster(getToolContext().getExchangeMaster()); securityGenerator.setRegionSource(getToolContext().getRegionSource()); securityGenerator.setOrganizationSource(getToolContext().getOrganizationSource()); securityGenerator.setSecurityMaster(getToolContext().getSecurityMaster()); securityGenerator.setHistoricalTimeSeriesMaster(getToolContext().getHistoricalTimeSeriesMaster()); } configureChain(securityGenerator); } protected void configureChain(final SecurityGenerator<?> securityGenerator) { if (getObjectContext() != null) { getObjectContext().configureChain(securityGenerator); } } protected void configure(final AbstractPortfolioGeneratorTool tool) { if (getRandom() != null) { tool.setRandom(getRandom()); } if (getToolContext() != null) { tool.setToolContext(getToolContext()); } if (getSecurityPersister() != null) { tool.setSecurityPersister(getSecurityPersister()); } if (getCounterPartyGenerator() != null) { tool.setCounterPartyGenerator(getCounterPartyGenerator()); } } /** * Command line option for specifying the portfolio name to generate. */ public static final String PORTFOLIO_OPT = "portfolio"; /** * Command line option to specifying the asset class to generate the portfolio for. */ public static final String SECURITY_OPT = "security"; /** * Command line option to specify to write to the database masters. */ public static final String WRITE_OPT = "write"; /** * Command line option to specifying the name of the counter party to use for trades. */ public static final String COUNTER_PARTY_OPT = "counterPty"; private static final String CURRENCIES_OPT = "currencies"; private AbstractPortfolioGeneratorTool getInstance(final Class<?> clazz, final String security) { if (!AbstractPortfolioGeneratorTool.class.isAssignableFrom(clazz)) { throw new OpenGammaRuntimeException("Couldn't find generator tool class for " + security); } try { final String className; final int i = security.indexOf('.'); if (i < 0) { className = clazz.getPackage().getName() + "." + security + "PortfolioGeneratorTool"; } else { className = security; } final Class<?> instanceClass; try { s_logger.debug("Trying class {}", className); instanceClass = Class.forName(className); } catch (final ClassNotFoundException e) { return getInstance(clazz.getSuperclass(), security); } s_logger.info("Loading {}", className); final AbstractPortfolioGeneratorTool tool = (AbstractPortfolioGeneratorTool) instanceClass .newInstance(); tool.setContext(getClassContext(), this); return tool; } catch (final Exception e) { throw new OpenGammaRuntimeException("Couldn't create generator tool instance for " + security, e); } } protected AbstractPortfolioGeneratorTool getInstance(final String security) { return getInstance(getClassContext(), security); } public void run(final ToolContext context, final String portfolioName, final String security, final boolean write, final Currency[] currencies) { final AbstractPortfolioGeneratorTool instance = getInstance(security); instance.setToolContext(context); instance.setCounterPartyGenerator(getCounterPartyGenerator()); instance.setRandom(new SecureRandom()); final SecuritySource securitySource; if (write) { s_logger.info("Creating database security writer"); securitySource = context.getSecuritySource(); instance.setSecurityPersister(new MasterSecurityPersister(context.getSecurityMaster())); } else { s_logger.info("Using dummy security writer"); final InMemorySecurityPersister securityPersister = new InMemorySecurityPersister(); instance.setSecurityPersister(securityPersister); securitySource = securityPersister.getSecuritySource(); } if (currencies != null && currencies.length > 0) { instance.setCurrencies(currencies); } s_logger.info("Creating portfolio {}", portfolioName); final Portfolio portfolio = instance.createPortfolio(portfolioName); if (write) { s_logger.info("Writing portfolio to the database"); final ManageablePortfolio newPortfolio = new ManageablePortfolio(portfolio.getName()); newPortfolio.setAttributes(portfolio.getAttributes()); newPortfolio.setRootNode(createPortfolioNode(context.getPositionMaster(), portfolio.getRootNode())); final PortfolioSearchRequest request = new PortfolioSearchRequest(); request.setDepth(0); request.setIncludePositions(false); request.setName(portfolio.getName()); final PortfolioSearchResult result = context.getPortfolioMaster().search(request); PortfolioDocument document = result.getFirstDocument(); if (document != null) { s_logger.info("Overwriting portfolio {}", document.getUniqueId()); document.setPortfolio(newPortfolio); context.getPortfolioMaster().update(document); } else { document = new PortfolioDocument(newPortfolio); context.getPortfolioMaster().add(document); } } else { if (s_logger.isDebugEnabled()) { s_logger.debug("Portfolio {}", portfolioName); writePortfolio(securitySource, portfolio.getRootNode(), ""); } } } private ManageablePortfolioNode createPortfolioNode(final PositionMaster positionMaster, final PortfolioNode node) { final ManageablePortfolioNode newNode = new ManageablePortfolioNode(node.getName()); for (final PortfolioNode child : node.getChildNodes()) { newNode.addChildNode(createPortfolioNode(positionMaster, child)); } for (final Position position : node.getPositions()) { final ManageablePosition newPosition = new ManageablePosition(); newPosition.setAttributes(position.getAttributes()); newPosition.setQuantity(position.getQuantity()); newPosition.setSecurityLink(new ManageableSecurityLink(position.getSecurityLink())); for (final Trade trade : position.getTrades()) { newPosition.addTrade(new ManageableTrade(trade)); } newNode.addPosition(positionMaster.add(new PositionDocument(newPosition)).getUniqueId()); } return newNode; } private void writePortfolio(final SecuritySource securitySource, final PortfolioNode node, final String indent) { s_logger.debug("{}+{}", indent, node.getName()); for (final PortfolioNode childNode : node.getChildNodes()) { writePortfolio(securitySource, childNode, indent + " "); } for (final Position position : node.getPositions()) { final Security security = position.getSecurityLink().resolve(securitySource); s_logger.debug("{} {} x {}", new Object[] { indent, position.getQuantity(), security }); } } private Option required(final Option option) { option.setRequired(true); return option; } @SuppressWarnings("static-access") public void createOptions(final Options options) { options.addOption( required(new Option("p", PORTFOLIO_OPT, true, "sets the name of the portfolio to create"))); options.addOption(required( new Option("s", SECURITY_OPT, true, "selects the asset class to populate the portfolio with"))); options.addOption(new Option("w", WRITE_OPT, false, "writes the portfolio and securities to the masters")); options.addOption(new Option("cp", COUNTER_PARTY_OPT, true, "sets the name of the counter party")); options.addOption(OptionBuilder.hasArgs().withArgName("Currency") .withDescription("Specify the currencies of the securities to be generated") .withLongOpt(CURRENCIES_OPT).create("ccy")); } private Currency[] parseCurrencies(final CommandLine commandLine) { if (commandLine.hasOption(CURRENCIES_OPT)) { final String[] currencies = commandLine.getOptionValues(CURRENCIES_OPT); final Currency[] ccys = new Currency[currencies.length]; int i = 0; for (final String ccyStr : currencies) { ccys[i++] = Currency.of(ccyStr.trim()); } return ccys; } else { return null; } } public void run(final ToolContext context, final CommandLine commandLine) { setCounterPartyGenerator( new StaticNameGenerator(commandLine.getOptionValue(COUNTER_PARTY_OPT, DEFAULT_COUNTER_PARTY))); run(context, commandLine.getOptionValue(PORTFOLIO_OPT), commandLine.getOptionValue(SECURITY_OPT), commandLine.hasOption(WRITE_OPT), parseCurrencies(commandLine)); } }