def setUp(self):
self.harness = SharedStateTestHarness.SharedStateTestHarness(True)
self.manager = SharedStateService.KeyspaceManager(10001,1, pingInterval=1)
self.introKeyspace = SharedState.getClientInfoKeyspace()
self.introRange = SharedState.KeyRange(self.introKeyspace, 1, None, None, True, False)
self.views = []
self.maxDiff = None
def __init__(self,
inMemory,
port=None,
cachePathOverride='',
maxOpenFiles=256,
inMemChannelFactoryFactory=None,
maxLogFileSizeMb=10,
pingInterval=None):
self.inMemory = inMemory
self.manager = None
self.callbackScheduler = CallbackScheduler.singletonForTesting()
if self.inMemory:
self.manager = SharedStateService.KeyspaceManager(
10001,
1,
cachePathOverride=cachePathOverride,
pingInterval=IN_MEMORY_HARNESS_PING_INTERVAL
if pingInterval is None else pingInterval,
maxOpenFiles=maxOpenFiles,
maxLogFileSizeMb=maxLogFileSizeMb)
#although named otherwise InMemoryChannelFactory is actually a factory for a channelFactory
# or a channelFactoryFactory
channelFactoryFactory = inMemChannelFactoryFactory if inMemChannelFactoryFactory is not None \
else InMemoryChannelFactory.InMemoryChannelFactory
logging.info(channelFactoryFactory)
self.channelFactory = channelFactoryFactory(
self.callbackScheduler, self.manager)
self.viewFactory = ViewFactory.ViewFactory(self.channelFactory)
else:
class Settings(object):
callbackScheduler = self.callbackScheduler
assert port is not None
self.service = SharedStateService.SharedStateService(
self.callbackScheduler,
cachePathOverride=cachePathOverride,
port=port)
self.service.startService()
self.service.blockUntilListening()
self.viewFactory = ViewFactory.ViewFactory.TcpViewFactory(
self.callbackScheduler, "localhost", port)
def createInMemorySharedStateViewFactory(callbackSchedulerToUse=None):
if callbackSchedulerToUse is None:
callbackSchedulerToUse = CallbackScheduler.singletonForTesting()
sharedStateManager = SharedStateService.KeyspaceManager(
10001,
1,
cachePathOverride="",
pingInterval=IN_MEMORY_CLUSTER_SS_PING_INTERVAL,
maxOpenFiles=100)
sharedStateChannelFactory = (
InMemorySharedStateChannelFactory.InMemoryChannelFactory(
callbackSchedulerToUse.getFactory().createScheduler(
"SharedState", 1), sharedStateManager))
return ViewFactory.ViewFactory(sharedStateChannelFactory)
def __init__(self,
cumulusVectorRamCacheSizeOverride = DEFAULT_VECTOR_RAM_CACHE_SIZE,
cumulusMaxRamCacheSizeOverride = DEFAULT_MAX_RAM_CACHE_SIZE,
cumulusThreadCountOverride = DEFAULT_THREAD_COUNT,
remoteGatewayRamCacheSizeOverride = DEFAULT_MAX_RAM_CACHE_SIZE,
perMachineThroughput = DEFAULT_PER_MACHINE_THROUGHPUT
):
self.cumulusMaxRamCacheSizeOverride = cumulusMaxRamCacheSizeOverride
self.cumulusVectorRamCacheSizeOverride = cumulusVectorRamCacheSizeOverride
self.callbackSchedulerFactory = CallbackScheduler.createSimpleCallbackSchedulerFactory()
self.callbackScheduler = self.callbackSchedulerFactory.createScheduler("InMemoryCluster", 1)
self.cumulusThreadCountOverride = cumulusThreadCountOverride
self.remoteGatewayCacheSize = remoteGatewayRamCacheSizeOverride
self.sharedStateManager = SharedStateService.KeyspaceManager(
10001,
1,
cachePathOverride="",
pingInterval = IN_MEMORY_CLUSTER_SS_PING_INTERVAL,
maxOpenFiles=100
)
self.sharedStateChannelFactory = (
InMemorySharedStateChannelFactory.InMemoryChannelFactory(
self.callbackScheduler,
self.sharedStateManager
)
)
self.sharedStateViewFactory = ViewFactory.ViewFactory(self.sharedStateChannelFactory)
self.client = InMemoryClient(self)
self.cumuli = []
self.nextCumulusAddress = 0
self.channelManager = InMemoryChannelManager(self.callbackScheduler, perMachineThroughput)
self.inMemoryDemuxingChannel = \
InMemorySharedStateChannelFactory.SerializedToManagerChannelFactory(
self.callbackScheduler,
self.sharedStateManager,
"SharedState"
)
