/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.bbg.test;
import java.lang.reflect.Method;
import org.fudgemsg.FudgeContext;
import org.fudgemsg.FudgeMsg;
import com.opengamma.bbg.BloombergConnector;
import com.opengamma.bbg.livedata.BloombergLiveDataServer;
import com.opengamma.bbg.livedata.faketicks.CombiningBloombergLiveDataServer;
import com.opengamma.bbg.livedata.faketicks.FakeSubscriptionBloombergLiveDataServer;
import com.opengamma.bbg.livedata.faketicks.FakeSubscriptionSelector;
import com.opengamma.bbg.referencedata.ReferenceDataProvider;
import com.opengamma.bbg.referencedata.cache.AbstractInvalidFieldCachingReferenceDataProvider;
import com.opengamma.bbg.referencedata.cache.AbstractValueCachingReferenceDataProvider;
import com.opengamma.bbg.referencedata.impl.BloombergReferenceDataProvider;
import com.opengamma.core.id.ExternalSchemes;
import com.opengamma.id.ExternalScheme;
import com.opengamma.livedata.resolver.DistributionSpecificationResolver;
import com.opengamma.livedata.server.CombiningLiveDataServer;
import com.opengamma.livedata.server.StandardLiveDataServer;
import com.opengamma.transport.FudgeMessageSender;
import com.opengamma.util.ehcache.EHCacheUtils;
import com.opengamma.util.fudgemsg.OpenGammaFudgeContext;
import net.sf.ehcache.CacheManager;
/**
* Test utilities for Bloomberg.
*/
public class BloombergLiveDataServerUtils {
/**
* Gets a reference data provider for a class, defined by a method.
*
* @param testMethod the test method, not null
* @return the data provider, not null
*/
public static ReferenceDataProvider getCachingReferenceDataProvider(Method testMethod) {
return getCachingReferenceDataProvider(testMethod.getClass());
}
/**
* Gets a reference data provider for a class.
*
* @param testClass the test class, not null
* @return the data provider, not null
*/
public static ReferenceDataProvider getCachingReferenceDataProvider(Class<?> testClass) {
BloombergReferenceDataProvider brdp = getUnderlyingProvider();
return getCachingReferenceDataProvider(brdp, testClass);
}
/**
* Adds caching to a reference data provider.
*
* @param underlying the underlying provider, not null
* @param testClass the test class, not null
* @return the data provider, not null
*/
private static ReferenceDataProvider getCachingReferenceDataProvider(ReferenceDataProvider underlying, Class<?> testClass) {
return MongoCachedReferenceData.makeMongoProvider(underlying, testClass);
}
/**
* Creates a Bloomberg reference data provider, that has been started, for testing.
*
* @return the provider, not null
*/
public static BloombergReferenceDataProvider getUnderlyingProvider() {
BloombergConnector connector = BloombergTestUtils.getBloombergConnector();
BloombergReferenceDataProvider brdp = new BloombergReferenceDataProvider(connector);
brdp.start();
return brdp;
}
/**
* Stops the specified reference data provider, as best as possible.
*
* @param refDataProvider the provider to stop, null ignored
*/
public static void stopCachingReferenceDataProvider(ReferenceDataProvider refDataProvider) {
if (refDataProvider != null) {
if (refDataProvider instanceof BloombergReferenceDataProvider) {
BloombergReferenceDataProvider bbgProvider = (BloombergReferenceDataProvider) refDataProvider;
bbgProvider.stop();
} else if (refDataProvider instanceof AbstractValueCachingReferenceDataProvider) {
stopCachingReferenceDataProvider(((AbstractValueCachingReferenceDataProvider) refDataProvider).getUnderlying());
} else if (refDataProvider instanceof AbstractInvalidFieldCachingReferenceDataProvider) {
stopCachingReferenceDataProvider(((AbstractInvalidFieldCachingReferenceDataProvider) refDataProvider).getUnderlying());
}
}
}
//-------------------------------------------------------------------------
public static BloombergLiveDataServer startTestServer(Method testMethod) {
return startTestServer(testMethod.getClass());
}
public static BloombergLiveDataServer startTestServer(Class<?> testClass) {
ReferenceDataProvider refDataProvider = getCachingReferenceDataProvider(testClass);
return getTestServer(refDataProvider);
}
public static void stopTestServer(BloombergLiveDataServer testServer) {
stopCachingReferenceDataProvider(testServer.getReferenceDataProvider());
testServer.stop();
}
public static BloombergLiveDataServer getTestServer(ReferenceDataProvider cachingRefDataProvider) {
FudgeMessageSender fudgeMessageSender = new FudgeMessageSender() {
@Override
public void send(FudgeMsg message) {
// do nothing
}
@Override
public FudgeContext getFudgeContext() {
return OpenGammaFudgeContext.getInstance();
}
};
BloombergLiveDataServer server = new BloombergLiveDataServer(BloombergTestUtils.getBloombergConnector(),
cachingRefDataProvider,
EHCacheUtils.createCacheManager(),
fudgeMessageSender);
DistributionSpecificationResolver distributionSpecificationResolver = server.getDefaultDistributionSpecificationResolver();
server.setDistributionSpecificationResolver(distributionSpecificationResolver);
server.start();
return server;
}
public static CombiningBloombergLiveDataServer startTestServer(Class<?> testClass, FakeSubscriptionSelector subscriptionSelector, ReferenceDataProvider refDataProvider) {
ReferenceDataProvider cachingRefDataProvider = getCachingReferenceDataProvider(refDataProvider, testClass);
BloombergLiveDataServer underlying = getTestServer(cachingRefDataProvider);
CacheManager cacheManager = EHCacheUtils.createCacheManager();
FakeSubscriptionBloombergLiveDataServer fakeServer = new FakeSubscriptionBloombergLiveDataServer(underlying, ExternalSchemes.BLOOMBERG_BUID_WEAK, cacheManager);
fakeServer.start();
CombiningBloombergLiveDataServer combinedServer = new CombiningBloombergLiveDataServer(fakeServer, underlying, subscriptionSelector, cacheManager);
combinedServer.start();
return combinedServer;
}
public static void stopTestServer(StandardLiveDataServer server) {
if (server instanceof BloombergLiveDataServer) {
stopTestServer((BloombergLiveDataServer) server);
} else if (server instanceof CombiningLiveDataServer) {
stopTestServer(((CombiningBloombergLiveDataServer) server).getFakeServer());
}
}
}