MarketDataManagerProxy.java

/*******************************************************************************
 * Copyright (c) 2013 Luigi Sgro. All rights reserved. This
 * program and the accompanying materials are made available under the terms of
 * the Eclipse Public License v1.0 which accompanies this distribution, and is
 * available at http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Luigi Sgro - initial API and implementation
 ******************************************************************************/
package com.quantcomponents.marketdata.osgi.proxy;

import java.net.ConnectException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.quantcomponents.core.exceptions.RequestFailedException;
import com.quantcomponents.core.model.BarSize;
import com.quantcomponents.core.model.DataType;
import com.quantcomponents.core.model.IContract;
import com.quantcomponents.core.model.IPrettyNamed;
import com.quantcomponents.core.model.ISeries;
import com.quantcomponents.core.model.ISeriesPoint;
import com.quantcomponents.core.model.ITaskMonitor;
import com.quantcomponents.core.remote.ITaskMonitorHostLocal;
import com.quantcomponents.core.remote.ServiceHandle;
import com.quantcomponents.marketdata.IMarketDataManager;
import com.quantcomponents.marketdata.IStockDatabase;
import com.quantcomponents.marketdata.osgi.IMarketDataManagerHost;
import com.quantcomponents.marketdata.osgi.IStockDatabaseHandleMap;
import com.quantcomponents.marketdata.osgi.IStockDatabaseHost;
import com.quantcomponents.marketdata.osgi.IStockDatabaseProxyFactory;

public class MarketDataManagerProxy implements IMarketDataManager, IStockDatabaseHandleMap, IPrettyNamed {
	private static final Logger logger = Logger.getLogger(MarketDataManagerProxy.class.getName());
	protected final Map<IStockDatabase, ServiceHandle<IStockDatabaseHost>> stockDbHandlesByStockDb = new ConcurrentHashMap<IStockDatabase, ServiceHandle<IStockDatabaseHost>>();
	protected final Map<ServiceHandle<IStockDatabaseHost>, IStockDatabase> stockDbProxiesByStockDbHandle = new ConcurrentHashMap<ServiceHandle<IStockDatabaseHost>, IStockDatabase>();
	protected volatile ITaskMonitorHostLocal taskMonitorHost;
	protected volatile IStockDatabaseProxyFactory stockDatabaseProxyFactory;
	private volatile IMarketDataManagerHost dataManagerHost;
	
	public MarketDataManagerProxy() {}

	public MarketDataManagerProxy(IMarketDataManagerHost dataManagerHost, ITaskMonitorHostLocal taskMonitorHost, IStockDatabaseProxyFactory stockDatabaseProxyFactory) {
		this.dataManagerHost = dataManagerHost;
		this.taskMonitorHost = taskMonitorHost;
		this.stockDatabaseProxyFactory = stockDatabaseProxyFactory;
	}
	
	public void deactivate() {
		stockDbHandlesByStockDb.clear();
		stockDbProxiesByStockDbHandle.clear();
	}
	
	public void setDataManagerHost(IMarketDataManagerHost dataManagerHost, Map<?,?> properties) {
		this.dataManagerHost = dataManagerHost;
	}

	protected IMarketDataManagerHost getMarketDataManagerHost() {
		return dataManagerHost;
	}
	
	public void setTaskMonitorHost(ITaskMonitorHostLocal taskMonitorHost) {
		this.taskMonitorHost = taskMonitorHost;
	}

	public void setStockDatabaseProxyFactory(IStockDatabaseProxyFactory stockDatabaseProxyFactory) {
		this.stockDatabaseProxyFactory = stockDatabaseProxyFactory;
	}

	@Override
	public String getPrettyName() {
		return getMarketDataManagerHost().getPrettyName();
	}

	@Override
	public DataType[] availableDataTypes() {
		return getMarketDataManagerHost().availableDataTypes();
	}

	@Override
	public BarSize[] availableBarSizes() {
		return getMarketDataManagerHost().availableBarSizes();
	}

	@Override
	public List<IContract> searchContracts(IContract criteria, ITaskMonitor taskMonitor) throws ConnectException, RequestFailedException {
		return getMarketDataManagerHost().searchContracts(criteria, taskMonitor == null ? null : taskMonitorHost.addTaskMonitor(taskMonitor));
	}

	@Override
	public Collection<IStockDatabase> allStockDatabases() {
		Collection<IStockDatabase> result = new ArrayList<IStockDatabase>();
		for (ServiceHandle<IStockDatabaseHost> handle : getMarketDataManagerHost().getAllStockDatabases()) {
			result.add(getOrCreateStockDbProxy(handle));
		}
		return result;
	}

	@Override
	public IStockDatabase findStockDatabase(IContract contract, DataType dataType, BarSize barSize, Boolean includeAfterHours) {
		ServiceHandle<IStockDatabaseHost> stockDbHandle = getMarketDataManagerHost().findStockDatabase(contract, dataType, barSize, includeAfterHours);
		if (stockDbHandle != null) {
			return getOrCreateStockDbProxy(stockDbHandle);
		}
		return null;
	}

	@Override
	public IStockDatabase getStockDatabase(String ID) {
		ServiceHandle<IStockDatabaseHost> stockDbHandle = null;
		try {
			stockDbHandle = getMarketDataManagerHost().getStockDatabase(ID);
		} catch (Exception e) {
			logger.log(Level.SEVERE, "Error while retrieving stock DB handle from host for ID: " + ID, e);
		} 
		if (stockDbHandle != null) {
			return getOrCreateStockDbProxy(stockDbHandle);
		}
		return null;
	}

	@Override
	public ISeries<Date, Double, ? extends ISeriesPoint<Date, Double>> getSeries(String ID) {
		return getStockDatabase(ID).getVirtualTimeSeries();
	}
	
	@Override
	public IStockDatabase createStockDatabase(IContract contract, DataType dataType, BarSize barSize, boolean includeAfterHours, TimeZone timeZone) {
		ServiceHandle<IStockDatabaseHost> stockDbHandle = getMarketDataManagerHost().createStockDatabase(contract, dataType, barSize, includeAfterHours, timeZone);
		return getOrCreateStockDbProxy(stockDbHandle);
	}

	@Override
	public void removeStockDatabase(IStockDatabase stockDb) throws ConnectException, RequestFailedException {
		ServiceHandle<IStockDatabaseHost> stockDbHandle = stockDbHandlesByStockDb.remove(stockDb);
		if (stockDbHandle == null) {
			throw new IllegalArgumentException("Stock database not found: " + stockDb);
		}
		getMarketDataManagerHost().removeStockDatabase(stockDbHandle);
		stockDbProxiesByStockDbHandle.remove(stockDbHandle);
	}

	@Override
	public void fillHistoricalData(IStockDatabase stockDb, Date startDate, Date endDate, ITaskMonitor taskMonitor) throws ConnectException, RequestFailedException {
		ServiceHandle<IStockDatabaseHost> stockDbHandle = stockDbHandlesByStockDb.get(stockDb);
		if (stockDbHandle == null) {
			throw new IllegalArgumentException("Stock database not found: " + stockDb);
		}
		getMarketDataManagerHost().fillHistoricalData(stockDbHandle, startDate, endDate,  taskMonitor == null ? null : taskMonitorHost.addTaskMonitor(taskMonitor));
	}

	protected ServiceHandle<IStockDatabaseHost> retrieveStockDatabaseHandle(IStockDatabase stockDb) {
		ServiceHandle<IStockDatabaseHost> stockDbHandle = stockDbHandlesByStockDb.get(stockDb);
		if (stockDbHandle == null) {
			throw new IllegalArgumentException("Stock database not found: " + stockDb);
		}
		return stockDbHandle;
	}
	
	private IStockDatabase getOrCreateStockDbProxy(ServiceHandle<IStockDatabaseHost> stockDbHandle) {
		IStockDatabase proxy = stockDbProxiesByStockDbHandle.get(stockDbHandle);
		if (proxy == null) {
			proxy = stockDatabaseProxyFactory.createStockDatabaseProxy(stockDbHandle);
			stockDbHandlesByStockDb.put(proxy, stockDbHandle);
			stockDbProxiesByStockDbHandle.put(stockDbHandle, proxy);
		}
		return proxy;
	}

	@Override
	public int numberOfStockDatabases() {
		return getMarketDataManagerHost().numberOfStockDatabases();
	}

	@Override
	public ServiceHandle<IStockDatabaseHost> getHandleByStockDb(IStockDatabase stockDb) {
		return retrieveStockDatabaseHandle(stockDb);
	}

	@Override
	public IStockDatabase getStockDbByHandle(ServiceHandle<IStockDatabaseHost> stockDbHandle) {
		return stockDbProxiesByStockDbHandle.get(stockDbHandle);
	}
}