mirror of
https://github.com/evennia/evennia.git
synced 2026-03-16 21:06:30 +01:00
310 lines
10 KiB
Python
310 lines
10 KiB
Python
"""
|
|
Dummy client runner
|
|
|
|
This module implements a stand-alone launcher for stress-testing
|
|
an Evennia game. It will launch any number of fake clients. These
|
|
clients will log into the server and start doing random operations.
|
|
Customizing and weighing these operations differently depends on
|
|
which type of game is tested. The module contains a testing module
|
|
for plain Evennia.
|
|
|
|
Please note that you shouldn't run this on a production server!
|
|
Launch the program without any arguments or options to see a
|
|
full step-by-step setup help.
|
|
|
|
Basically (for testing default Evennia):
|
|
|
|
- Use an empty/testing database.
|
|
- set PERMISSION_PLAYER_DEFAULT = "Builders"
|
|
- start server, eventually with profiling active
|
|
- launch this client runner
|
|
|
|
If you want to customize the runner's client actions
|
|
(because you changed the cmdset or needs to better
|
|
match your use cases or add more actions), you can
|
|
change which actions by adding a path to
|
|
|
|
DUMMYRUNNER_ACTIONS_MODULE = <path.to.your.module>
|
|
|
|
in your settings. See utils.dummyrunner_actions.py
|
|
for instructions on how to define this module.
|
|
|
|
"""
|
|
|
|
import time, random
|
|
from argparse import ArgumentParser
|
|
from twisted.conch import telnet
|
|
from twisted.internet import reactor, protocol
|
|
from twisted.internet.task import LoopingCall
|
|
|
|
from django.conf import settings
|
|
from evennia.utils import mod_import, time_format
|
|
|
|
# Load the dummyrunner settings module
|
|
|
|
DUMMYRUNNER_SETTINGS = mod_import(settings.DUMMYRUNNER_SETTINGS_MODULE)
|
|
DATESTRING = "%Y%m%d%H%M%S"
|
|
|
|
# Settings
|
|
|
|
# number of clients to launch if no input is given on command line
|
|
NCLIENTS = 1
|
|
# time between each 'tick', in seconds, if not set on command
|
|
# line. All launched clients will be called upon to possibly do an
|
|
# action with this frequency.
|
|
TIMESTEP = DUMMYRUNNER_SETTINGS.TIMESTEP
|
|
# chance of a client performing an action, per timestep. This helps to
|
|
# spread out usage randomly, like it would be in reality.
|
|
CHANCE_OF_ACTION = DUMMYRUNNER_SETTINGS.CHANCE_OF_ACTION
|
|
# spread out the login action separately, having many players create accounts
|
|
# and connect simultaneously is generally unlikely.
|
|
CHANCE_OF_LOGIN = DUMMYRUNNER_SETTINGS.CHANCE_OF_LOGIN
|
|
# Port to use, if not specified on command line
|
|
TELNET_PORT = DUMMYRUNNER_SETTINGS.TELNET_PORT or settings.TELNET_PORTS[0]
|
|
#
|
|
NLOGGED_IN = 0
|
|
|
|
# Messages
|
|
|
|
INFO_STARTING = \
|
|
"""
|
|
Dummyrunner starting using {N} dummy player(s). If you don't see
|
|
any connection messages, make sure that the Evennia server is
|
|
running. If you intend the dummies to work fully, set
|
|
settings.PERMISSION_PLAYER_DEFAULT appropriately (if so it is
|
|
recommended that you use a temporary testing database).
|
|
|
|
Use Ctrl-C to stop/disconnect clients.
|
|
"""
|
|
|
|
ERROR_FEW_ACTIONS = \
|
|
"""
|
|
Dummyrunner settings error: The ACTIONS tuple is too short: it must
|
|
contain at least login- and logout functions.
|
|
"""
|
|
|
|
|
|
HELPTEXT = """
|
|
DO NOT RUN THIS ON A PRODUCTION SERVER! USE A CLEAN/TESTING DATABASE!
|
|
|
|
This stand-alone program launches dummy telnet clients against a
|
|
running Evennia server. The idea is to mimic real players logging in
|
|
and repeatedly doing resource-heavy commands so as to stress test the
|
|
game. It uses the default command set to log in and issue commands, so
|
|
if that was customized, some of the functionality will not be tested
|
|
(it will not fail, the commands will just not be recognized). The
|
|
running clients will create new objects and rooms all over the place
|
|
as part of their running, so using a clean/testing database is
|
|
strongly recommended.
|
|
|
|
Setup:
|
|
1) setup a fresh/clean database (if using sqlite, just safe-copy
|
|
away your real evennia.db3 file and create a new one with
|
|
manage.py)
|
|
2) in server/conf/settings.py, add
|
|
|
|
PERMISSION_PLAYER_DEFAULT="Builders"
|
|
|
|
This is so that the dummy players can test building operations.
|
|
You can also customize the dummyrunner by modifying a setting
|
|
file specified by DUMMYRUNNER_SETTINGS_MODULE
|
|
|
|
3) Start Evennia like normal, optionally with profiling (--profile)
|
|
4) Run this dummy runner via the evennia launcher:
|
|
|
|
evennia --dummyrunner <nr_of_clients>
|
|
|
|
5) Log on and determine if game remains responsive despite the
|
|
heavier load. Note that if you do profiling, there is an
|
|
additional overhead from the profiler too!j
|
|
6) If you use profiling, let the game run long enough to gather
|
|
data, then stop the server cleanly using evennia stop or @shutdown.
|
|
@shutdown. The profile appears as
|
|
server/logs/server.prof/portal.prof (see Python's manual on
|
|
cProfiler).
|
|
|
|
"""
|
|
|
|
#------------------------------------------------------------
|
|
# Helper functions
|
|
#------------------------------------------------------------
|
|
|
|
|
|
ICOUNT = 0
|
|
def idcounter():
|
|
"makes unique ids"
|
|
global ICOUNT
|
|
ICOUNT += 1
|
|
return str(ICOUNT)
|
|
|
|
|
|
GCOUNT = 0
|
|
def gidcounter():
|
|
"makes globally unique ids"
|
|
global GCOUNT
|
|
GCOUNT += 1
|
|
return "%s-%s" % (time.strftime(DATESTRING), GCOUNT)
|
|
|
|
|
|
def makeiter(obj):
|
|
"makes everything iterable"
|
|
if not hasattr(obj, '__iter__'):
|
|
return [obj]
|
|
return obj
|
|
|
|
#------------------------------------------------------------
|
|
# Client classes
|
|
#------------------------------------------------------------
|
|
|
|
class DummyClient(telnet.StatefulTelnetProtocol):
|
|
"""
|
|
Handles connection to a running Evennia server,
|
|
mimicking a real player by sending commands on
|
|
a timer.
|
|
"""
|
|
|
|
def connectionMade(self):
|
|
|
|
# public properties
|
|
self.cid = idcounter()
|
|
self.key = "Dummy-%s" % self.cid
|
|
self.gid = "%s-%s" % (time.strftime(DATESTRING), self.cid)
|
|
self.istep = 0
|
|
self.exits = [] # exit names created
|
|
self.objs = [] # obj names created
|
|
|
|
self._loggedin = False
|
|
self._logging_out = False
|
|
self._report = ""
|
|
self._cmdlist = [] # already stepping in a cmd definition
|
|
self._login = self.factory.actions[0]
|
|
self._logout = self.factory.actions[1]
|
|
self._actions = self.factory.actions[2:]
|
|
|
|
reactor.addSystemEventTrigger('before', 'shutdown', self.logout)
|
|
|
|
# start client tick
|
|
d = LoopingCall(self.step)
|
|
# dissipate exact step by up to +/- 0.5 second
|
|
timestep = TIMESTEP + (-0.5 + (random.random()*1.0))
|
|
d.start(timestep, now=True).addErrback(self.error)
|
|
|
|
|
|
def dataReceived(self, data):
|
|
"Echo incoming data to stdout"
|
|
pass
|
|
|
|
def connectionLost(self, reason):
|
|
"loosing the connection"
|
|
if not self._logging_out:
|
|
print "client %s(%s) lost connection (%s)" % (self.key, self.cid, reason)
|
|
|
|
def error(self, err):
|
|
"error callback"
|
|
print err
|
|
|
|
def counter(self):
|
|
"produces a unique id, also between clients"
|
|
return gidcounter()
|
|
|
|
def logout(self):
|
|
"Causes the client to log out of the server. Triggered by ctrl-c signal."
|
|
self._logging_out = True
|
|
cmd = self._logout(self)
|
|
print "client %s(%s) logout (%s actions)" % (self.key, self.cid, self.istep)
|
|
self.sendLine(cmd)
|
|
|
|
def step(self):
|
|
"""
|
|
Perform a step. This is called repeatedly by the runner
|
|
and causes the client to issue commands to the server.
|
|
This holds all "intelligence" of the dummy client.
|
|
"""
|
|
global NLOGGED_IN
|
|
|
|
rand = random.random()
|
|
|
|
if not self._cmdlist:
|
|
# no commands ready. Load some.
|
|
|
|
if not self._loggedin:
|
|
if rand < CHANCE_OF_LOGIN:
|
|
# get the login commands
|
|
self._cmdlist = list(makeiter(self._login(self)))
|
|
NLOGGED_IN += 1 # this is for book-keeping
|
|
print "connecting client %s (%i/%i)..." % (self.key, NLOGGED_IN, NCLIENTS)
|
|
self._loggedin = True
|
|
else:
|
|
# no login yet, so cmdlist not yet set
|
|
return
|
|
else:
|
|
# we always pick a cumulatively random function
|
|
crand = random.random()
|
|
cfunc = [func for (cprob, func) in self._actions if cprob >= crand][0]
|
|
self._cmdlist = list(makeiter(cfunc(self)))
|
|
|
|
# at this point we always have a list of commands
|
|
if rand < CHANCE_OF_ACTION:
|
|
# send to the game
|
|
self.sendLine(str(self._cmdlist.pop(0)))
|
|
self.istep += 1
|
|
|
|
|
|
class DummyFactory(protocol.ClientFactory):
|
|
protocol = DummyClient
|
|
def __init__(self, actions):
|
|
"Setup the factory base (shared by all clients)"
|
|
self.actions = actions
|
|
|
|
#------------------------------------------------------------
|
|
# Access method:
|
|
# Starts clients and connects them to a running server.
|
|
#------------------------------------------------------------
|
|
|
|
def start_all_dummy_clients(nclients):
|
|
|
|
global NCLIENTS
|
|
NCLIENTS = int(nclients)
|
|
actions = DUMMYRUNNER_SETTINGS.ACTIONS
|
|
|
|
if len(actions) < 2:
|
|
print ERROR_FEW_ACTIONS
|
|
return
|
|
|
|
# make sure the probabilities add up to 1
|
|
pratio = 1.0 / sum(tup[0] for tup in actions[2:])
|
|
flogin, flogout, probs, cfuncs = actions[0], actions[1], [tup[0] * pratio for tup in actions[2:]], [tup[1] for tup in actions[2:]]
|
|
# create cumulative probabilies for the random actions
|
|
cprobs = [sum(v for i,v in enumerate(probs) if i<=k) for k in range(len(probs))]
|
|
# rebuild a new, optimized action structure
|
|
actions = (flogin, flogout) + tuple(zip(cprobs, cfuncs))
|
|
|
|
# setting up all clients (they are automatically started)
|
|
factory = DummyFactory(actions)
|
|
for i in range(NCLIENTS):
|
|
reactor.connectTCP("localhost", TELNET_PORT, factory)
|
|
# start reactor
|
|
reactor.run()
|
|
|
|
#------------------------------------------------------------
|
|
# Command line interface
|
|
#------------------------------------------------------------
|
|
|
|
if __name__ == '__main__':
|
|
|
|
# parsing command line with default vals
|
|
parser = ArgumentParser(description=HELPTEXT)
|
|
parser.add_argument("-N", nargs=1, default=1, dest="nclients",
|
|
help="Number of clients to start")
|
|
|
|
args = parser.parse_args()
|
|
|
|
print INFO_STARTING.format(N=args.nclients[0])
|
|
|
|
# run the dummyrunner
|
|
t0 = time.time()
|
|
start_all_dummy_clients(nclients=args.nclients[0])
|
|
ttot = time.time() - t0
|
|
|
|
# output runtime
|
|
print "... dummy client runner stopped after %s." % time_format(ttot, style=3)
|