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 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 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"
)
def startSharedState(args):
if parsed.cacheDir:
logging.info("Shared state cache directory: %s", parsed.cacheDir)
Setup.config().sharedStateCache = parsed.cacheDir
service = SharedStateService.SharedStateService(callbackScheduler)
service.startService()
service.blockUntilListening()
def handleSigTerm(signum, frame):
logging.info("SIGTERM received - shutting down")
service.stopService()
signal.signal(signal.SIGTERM, handleSigTerm)
signal.pause()
logging.info("process exiting")
def createSocketChannel(self, sock):
return SharedStateService.createClientSocketMessageChannel(
self.callbackScheduler, sock)
def createSocketChannel(self, sock):
return SharedStateService.createClientSocketMessageChannel(self.callbackScheduler, sock)
def onConnect(self, sock, address):
channel = SharedStateService.createServerSocketChannel(
callbackScheduler, sock)
channel.write(SharedState.MessageIn.MinimumId(0, 0))
self.serverChannel = channel
self.serverChannelEvent.set()
def connectToServer(self):
sock = SimpleServer.SimpleServer.connect('localhost', self.port)
return SharedStateService.createClientSocketMessageChannel(
callbackScheduler, sock)
def createSocketChannels(self, scheduler):
clientSock = SimpleServer.SimpleServer.connect('localhost', self.port)
serverSock = self.q.get()
return (SharedStateService.createClientSocketMessageChannel(scheduler, clientSock),
SharedStateService.createServerSocketChannel(scheduler, serverSock))
def createSocketChannels(self, scheduler):
clientSock = SimpleServer.SimpleServer.connect('localhost', self.port)
serverSock = self.q.get()
return (SharedStateService.createClientSocketMessageChannel(scheduler, clientSock),
SharedStateService.createServerSocketChannel(scheduler, serverSock))
def onConnect(self, sock, address):
channel = SharedStateService.createServerSocketChannel(callbackScheduler, sock)
channel.write(SharedState.MessageIn.MinimumId(0, 0))
self.serverChannel = channel
self.serverChannelEvent.set()
def connectToServer(self):
sock = SimpleServer.SimpleServer.connect("localhost", self.port)
return SharedStateService.createClientSocketMessageChannel(callbackScheduler, sock)
