Prototype Bond Calculator Doesn't seem to trigger any calculation on the Open Gamma server

PrototypeBondCalculator.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.net.URI;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import javax.time.Instant;
import javax.time.calendar.TimeZone;
import javax.time.calendar.ZonedDateTime;

import com.opengamma.component.ComponentInfo;
import com.opengamma.component.factory.RemoteComponentFactory;
import com.opengamma.component.rest.RemoteComponentServer;
import com.opengamma.core.config.impl.ConfigItem;
import com.opengamma.engine.marketdata.spec.MarketData;
import com.opengamma.engine.value.ValueRequirementNames;
import com.opengamma.engine.view.ResultModelDefinition;
import com.opengamma.engine.view.ViewCalculationConfiguration;
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.calc.ViewCycleMetadata;
import com.opengamma.engine.view.client.ViewClient;
import com.opengamma.engine.view.client.ViewResultMode;
import com.opengamma.engine.view.compilation.CompiledViewDefinition;
import com.opengamma.engine.view.execution.ExecutionOptions;
import com.opengamma.engine.view.execution.ViewCycleExecutionOptions;
import com.opengamma.engine.view.listener.ViewResultListener;
import com.opengamma.financial.convention.daycount.ActualActualICMA;
import com.opengamma.financial.convention.daycount.DayCount;
import com.opengamma.financial.convention.frequency.Frequency;
import com.opengamma.financial.convention.frequency.SimpleFrequency;
import com.opengamma.financial.convention.yield.SimpleYieldConvention;
import com.opengamma.financial.convention.yield.YieldConvention;
import com.opengamma.financial.security.bond.CorporateBondSecurity;
import com.opengamma.financial.user.FinancialUserManager;
import com.opengamma.financial.user.rest.RemoteClient;
import com.opengamma.id.ExternalIdBundle;
import com.opengamma.id.UniqueId;
import com.opengamma.livedata.UserPrincipal;
import com.opengamma.master.config.ConfigMaster;
import com.opengamma.master.config.ConfigMasterUtils;
import com.opengamma.master.portfolio.ManageablePortfolio;
import com.opengamma.master.portfolio.ManageablePortfolioNode;
import com.opengamma.master.portfolio.PortfolioDocument;
import com.opengamma.master.portfolio.PortfolioMaster;
import com.opengamma.master.position.ManageablePosition;
import com.opengamma.master.position.PositionDocument;
import com.opengamma.master.position.PositionMaster;
import com.opengamma.master.security.ManageableSecurity;
import com.opengamma.master.security.SecurityDocument;
import com.opengamma.master.security.SecurityMaster;
import com.opengamma.util.fudgemsg.OpenGammaFudgeContext;
import com.opengamma.util.money.Currency;
import com.opengamma.util.time.Expiry;

public class PrototypeBondCalculator implements ViewResultListener {
  
	

	// Simple test to construct repos
	// Add a bond as temp data
	// Calculate some outputs from the bond
	public static void main(String [] args)
	{
		PrototypeBondCalculator proto = new PrototypeBondCalculator();
		
		RemoteComponentServer remoteComponentServer = proto.GetRemoteComponentServer();
		
		RemoteClient remoteClient = proto.GetRemoteClient(remoteComponentServer);
		
		// Create example bond security (instrument)
		
		PortfolioMaster portfolioMaster = remoteClient.getPortfolioMaster();
		PositionMaster positionMaster = remoteClient.getPositionMaster();
		SecurityMaster securityMaster = remoteClient.getSecurityMaster();
		
		ConfigMaster viewDefinitionRepository = remoteClient.getConfigMaster();
		
		
		// create bond security	
	    CorporateBondSecurity bondInstrument = new CorporateBondSecurity(
	    		"Bank Of America Corp", // issuer name
	    		"Banks", // issuer type
	    		"US", // issuer domicile
	    		"OTC", // market
	    		Currency.EUR, // currency
	    		SimpleYieldConvention.US_BOND, // yield convention
	    		new Expiry(ZonedDateTime.of(2017,4,3, 0,0,0,0, TimeZone.UTC)), // last trade date
	    		"FIXED", // coupon type
	    		0.0475, // coupon rate
	    		SimpleFrequency.ANNUAL, // coupon frequency
	    		new ActualActualICMA(), // day count convention
	    		ZonedDateTime.of(2010, 3, 18, 0,0,0,0, TimeZone.UTC), // interestAccrualDate
	    		ZonedDateTime.of(2017, 4, 3, 0,0,0,0, TimeZone.UTC), // settlementDate
	    		ZonedDateTime.of(2011, 4, 3, 0,0,0,0, TimeZone.UTC), // firstCouponDate
	    		1.0, // issuancePrice
	    		1500000000.0, // totalAmountIssued
	    		0.0, // minimumAmount
	    		0.0, // minimumIncrement
	    		0.0, // parAmount
	    		0.0 // redemptionValue
	    		);
		

		// wrap in SecurityDocument
		// add to security repository
	    SecurityDocument securityDocument = securityMaster.add(new SecurityDocument(bondInstrument));
	    ManageableSecurity sec = securityDocument.getSecurity();		    
	    ExternalIdBundle secBundleId = sec.getExternalIdBundle();
		    
		    
		// create position from security document and add to repo
		ManageablePosition manageablePosition = new ManageablePosition(new BigDecimal(1000.0), secBundleId);
		PositionDocument positionDocument = positionMaster.add(new PositionDocument(manageablePosition));
		
		// create portfolio node
		ManageablePortfolioNode manageablePortfolioNode = new ManageablePortfolioNode("Child");
		manageablePortfolioNode.addPosition(positionDocument);
		
		
		// create portfolio with position and add to repo
		ManageablePortfolio manageablePortfolio = new ManageablePortfolio("Test Fund");
		manageablePortfolio.getRootNode().setName("RootNode");
		manageablePortfolio.getRootNode().addChildNode(manageablePortfolioNode);
		
		
		PortfolioDocument portfolioDocument = portfolioMaster.add(new PortfolioDocument(manageablePortfolio));
		
		
		// Create the view definition		
		ViewDefinition viewDefinition = 
				new ViewDefinition(
					"MyBondView", 
					portfolioDocument.getUniqueId(), 
					UserPrincipal.getLocalUser()
					);
		
		
		// Create a view calc config
		ViewCalculationConfiguration viewCalcConfig = new ViewCalculationConfiguration(viewDefinition, "BondViewCalc");
		
		// Set output requirements
		Set<String> requirementNames = new HashSet<String>(Arrays.asList(
						ValueRequirementNames.CONVEXITY, 
						ValueRequirementNames.MODIFIED_DURATION,
						ValueRequirementNames.BOND_COUPON_PAYMENT_TIMES,
						ValueRequirementNames.BOND_TENOR)); 
		
		viewCalcConfig.addPortfolioRequirementNames(bondInstrument.getSecurityType(), requirementNames);
		
		// Add view calc config to view def
		viewDefinition.addViewCalculationConfiguration(viewCalcConfig);
		
		// add view def to master
		ConfigItem<ViewDefinition> viewDefinitionItem = ConfigMasterUtils.storeByName(viewDefinitionRepository, ConfigItem.of(viewDefinition));
		
		
		// Create a client and subscribe
		ViewProcessor viewProcessor = proto.GetViewProcessor();
		ViewClient viewClient = proto.GetViewClient(viewProcessor);
		
		
		viewClient.setResultMode(ViewResultMode.FULL_ONLY);
		viewClient.setResultListener(proto);
		
		viewClient.attachToViewProcess(viewDefinitionItem.getUniqueId(), ExecutionOptions.infinite(MarketData.live()));
		
		
		
		// DEBUG code to pause main thread 
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));		
		try
		{
			br.readLine();
		}
		catch(IOException ex)
		{
		
		}
		
		
		viewClient.detachFromViewProcess();
		
		viewClient.shutdown();
	}
	
	private static final String _endpointAddress = "http://localhost:8080/jax";
	
	static public ViewProcessor GetViewProcessor()
	{
		URI baseUri = URI.create(_endpointAddress);
		RemoteComponentFactory componentFactory = new RemoteComponentFactory(baseUri);
		ViewProcessor viewProcessor = componentFactory.getViewProcessor("main");
		return viewProcessor;
	}
	
	static public ViewClient GetViewClient(ViewProcessor viewProcessor)
	{
		UserPrincipal localUser = UserPrincipal.getLocalUser();
		ViewClient viewClient = viewProcessor.createViewClient(localUser);
		return viewClient;
	}
	
	static public RemoteComponentServer GetRemoteComponentServer()
	{
		URI baseUri = URI.create(_endpointAddress);
		RemoteComponentServer cs = new RemoteComponentServer(baseUri);
		return cs;
	}
	
	static public RemoteClient GetRemoteClient(RemoteComponentServer cs)
	{
		ComponentInfo info = cs.getComponentServer().getComponentInfo(FinancialUserManager.class, "main");

		URI userManagerUri = info.getUri();
		RemoteClient remoteClient = RemoteClient.forNewClient(OpenGammaFudgeContext.getInstance(), userManagerUri, UserPrincipal.getLocalUser().getUserName());
		
		// Set up the client's heartbeating
		ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
		scheduler.scheduleWithFixedDelay(remoteClient.createHeartbeatSender(), 5, 5, TimeUnit.MINUTES);
		
		return remoteClient;
	}
	
	

	
	@Override
	public UserPrincipal getUser() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public void viewDefinitionCompiled(
			CompiledViewDefinition compiledViewDefinition,
			boolean hasMarketDataPermissions) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void viewDefinitionCompilationFailed(Instant valuationTime,
			Exception exception) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void cycleStarted(ViewCycleMetadata cycleMetadata) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void cycleFragmentCompleted(ViewComputationResultModel fullFragment,
			ViewDeltaResultModel deltaFragment) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void cycleCompleted(ViewComputationResultModel fullResult,
			ViewDeltaResultModel deltaResult) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void cycleExecutionFailed(
			ViewCycleExecutionOptions executionOptions, Exception exception) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void processCompleted() {
		
		// TODO Auto-generated method stub
		
	}

	@Override
	public void processTerminated(boolean executionInterrupted) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void clientShutdown(Exception e) {
		// TODO Auto-generated method stub
		
	}
	
	
}