def test_listsize(self): a_list = [1,2,3,4] ivc = CallbackCounter('test_counter', lambda: len(a_list)) # in this case the callback can also be a_list.__len__ self.assertEqual(ivc.get_current(), 4) a_list.extend([5,6,7]) self.assertEqual(ivc.get_current(), 7) a_list.remove(1) self.assertEqual(ivc.get_current(), 6)
def __init__(self, pdbhelper, rootcc, qmangr, to_eventprocessor, cshardmgr_interface): """@type pdbhelper: L{lobbyapp.playerdb.api.PDBHelperInterface} implementation. @type qmangr: L{lobbyapp.queuemangr.QueueManager} @param to_eventprocessor: Queue that can be used to send orders to EventProcessor @type to_eventprocessor: L{Queue.Queue} @param cshardmgr_interface: interface to CShardMgr @type cshardmgr_interface: tuple(str, int)""" Monitor.__init__(self) self.pirs = {} #: pid => PlayerInformationRecord self.cshardmgr_interface = cshardmgr_interface self.pdbhelper = pdbhelper self.qmangr = qmangr self.alphas = [] # all existing AlphaMatches self.betagammas = [] # all existing BetaGammas self.to_eventprocessor = to_eventprocessor cc = CounterCollection('player_database') self.transactions_counter = PulseCounter( 'transactions', resolution=60, units=u'transactions per minute', description=u'player database transactions performed') alphas_waiting = CallbackCounter('alphas_waiting', self.alphas.__len__, description=u'matches being prepared') betagammas = CallbackCounter('betagammas', self.betagammas.__len__, description=u'matches being played') cc.add(self.transactions_counter) cc.add(alphas_waiting) cc.add(betagammas) rootcc.add(cc)
def __init__(self, server_sockets, rootcc): SelectHandlingLayer.__init__(self) # process server sockets self.server_sockets = server_sockets # there may be many for server_socket in server_sockets: self.register_channel(server_socket) self.reqtasks = [] # ---------- instrumentation stuff self.c_lshardmgrs_connected = DeltaCounter('lshardmgrs_connected', description='Amount of lshardmgrs connected') self.c_requests_dispatched = PulseCounter('requests_dispatched', resolution=60, units=u'requests per minute', description='Requests to allocate a server sent') self.c_alloc_orders = PulseCounter('allocation_orders', resolution=60, units=u'allocation requests per minute', description=u'Allocation requests received') self.c_requests_success = PulseCounter('requests_successful', resolution=60, units=u'successful requests per minute', description=u'Requests successfully executed') self.c_requests_failed = PulseCounter('requests_failed', resolution=60, units=u'failed requests per minute', description=u'Failed requests') def calculate_shards_available(): a = [x for x in self.channels if x not in self.server_sockets] a = [x for x in a if x.who == 'l'] return sum([x.shards for x in a]) self.c_shards_available = CallbackCounter('shards_available', calculate_shards_available, units=u'shards', description=u'Available shards') rootcc.add(self.c_lshardmgrs_connected) rootcc.add(self.c_requests_dispatched) rootcc.add(self.c_alloc_orders) rootcc.add(self.c_requests_success) rootcc.add(self.c_requests_failed) rootcc.add(self.c_shards_available)
def __init__(self, qname, ppm, rootcc): """ Constructs the queue @param qname: queue name identifier @type qname: str @param ppm: Players required per match of this type @type ppm: int @param rootcc: Collection counter for queues """ self.qname = qname #: name of the queue self.players_per_match = ppm self.players = [] #: pids of players in queue # ---------------- instrumentation section cc = CounterCollection(self.qname) players_counter = CallbackCounter('players', lambda: len(self.players), description=u'players waiting in this queue') cc.add(players_counter) rootcc.add(cc)
def test_disabling(self): ivc = CallbackCounter('test_counter', lambda: 0) ivc.disable() self.assertRaises(NoData, ivc.get_current) ivc.enable() self.assertEqual(ivc.get_current(), 0)