mirror of
https://github.com/evennia/evennia.git
synced 2026-04-04 15:07:16 +02:00
688 lines
22 KiB
Python
688 lines
22 KiB
Python
"""
|
|
This file contains commands that require special permissions to
|
|
use. These are generally @-prefixed commands, but there are
|
|
exceptions.
|
|
"""
|
|
|
|
import traceback
|
|
from django.contrib.auth.models import User
|
|
from src.server import sessionhandler
|
|
from src.players.models import PlayerDB
|
|
from src.scripts.models import ScriptDB
|
|
from src.objects.models import ObjectDB
|
|
from src.permissions.models import PermissionGroup
|
|
from src.scripts.scripthandler import format_script_list
|
|
from src.utils import reloads, create, logger, utils
|
|
from src.permissions.permissions import has_perm
|
|
from game.gamesrc.commands.default.muxcommand import MuxCommand
|
|
|
|
|
|
class CmdReload(MuxCommand):
|
|
"""
|
|
Reload the system
|
|
|
|
Usage:
|
|
@reload
|
|
|
|
This reloads the system modules and
|
|
re-validates all scripts.
|
|
"""
|
|
key = "@reload"
|
|
permissions = "cmd:reload"
|
|
help_category = "System"
|
|
|
|
def func(self):
|
|
"""
|
|
Reload the system.
|
|
"""
|
|
caller = self.caller
|
|
reloads.reload_modules()
|
|
|
|
max_attempts = 4
|
|
for attempt in range(max_attempts):
|
|
# if reload modules take a long time,
|
|
# we might end up in a situation where
|
|
# the subsequent commands fail since they
|
|
# can't find the reloads module (due to it
|
|
# not yet fully loaded). So we retry a few
|
|
# times before giving up.
|
|
try:
|
|
reloads.reload_scripts()
|
|
reloads.reload_commands()
|
|
break
|
|
except AttributeError:
|
|
if attempt < max_attempts-1:
|
|
caller.msg(" Waiting for modules(s) to finish (%s) ..." % attempt)
|
|
pass
|
|
else:
|
|
string = " ... The module(s) took too long to reload, "
|
|
string += "\n so the remaining reloads where skipped."
|
|
string += "\n Re-run @reload again when modules have fully "
|
|
string += "\n re-initialized."
|
|
caller.msg(string)
|
|
|
|
class CmdPy(MuxCommand):
|
|
"""
|
|
Execute a snippet of python code
|
|
|
|
Usage:
|
|
@py <cmd>
|
|
|
|
In this limited python environment, only two
|
|
variables are defined: 'self'/'me' which refers to one's
|
|
own object, and 'here' which refers to the current
|
|
location.
|
|
"""
|
|
key = "@py"
|
|
aliases = ["!"]
|
|
permissions = "cmd:py"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"hook function"
|
|
|
|
caller = self.caller
|
|
pycode = self.args
|
|
|
|
if not pycode:
|
|
string = "Usage: @py <code>"
|
|
caller.msg(string)
|
|
return
|
|
# create temporary test objects for playing with
|
|
script = create.create_script("src.scripts.scripts.DoNothing",
|
|
'testscript')
|
|
obj = create.create_object("src.objects.objects.Object",
|
|
'testobject')
|
|
available_vars = {'self':caller,
|
|
'me':caller,
|
|
'here':caller.location,
|
|
'obj':obj,
|
|
'script':script}
|
|
caller.msg(">>> %s" % pycode)
|
|
try:
|
|
ret = eval(pycode, {}, available_vars)
|
|
ret = "<<< %s" % str(ret)
|
|
except Exception:
|
|
try:
|
|
exec(pycode, {}, available_vars)
|
|
ret = "<<< Done."
|
|
except Exception:
|
|
errlist = traceback.format_exc().split('\n')
|
|
if len(errlist) > 4:
|
|
errlist = errlist[4:]
|
|
ret = "\n".join("<<< %s" % line for line in errlist if line)
|
|
caller.msg(ret)
|
|
obj.delete()
|
|
script.delete()
|
|
|
|
class CmdListScripts(MuxCommand):
|
|
"""
|
|
List all scripts.
|
|
|
|
Usage:
|
|
@scripts[/switches] [<obj or scriptid>]
|
|
|
|
Switches:
|
|
stop - stops an existing script
|
|
validate - run a validation on the script(s)
|
|
|
|
If no switches are given, this command just views all active
|
|
scripts. The argument can be either an object, at which point it
|
|
will be searched for all scripts defined on it, or an script name
|
|
or dbref. For using the /stop switch, a unique script dbref is
|
|
required since whole classes of scripts often have the same name.
|
|
"""
|
|
key = "@scripts"
|
|
aliases = "@listscripts"
|
|
permissions = "cmd:listscripts"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"implement method"
|
|
|
|
caller = self.caller
|
|
args = self.args
|
|
|
|
string = ""
|
|
if args:
|
|
# test first if this is an script match
|
|
scripts = ScriptDB.objects.get_all_scripts(key=args)
|
|
if not scripts:
|
|
# try to find an object instead.
|
|
objects = ObjectDB.objects.pobject_search(caller,
|
|
args,
|
|
global_search=True)
|
|
if objects:
|
|
scripts = []
|
|
for obj in objects:
|
|
# get all scripts on the object(s)
|
|
scripts.extend(ScriptDB.objects.get_all_scripts_on_obj(obj))
|
|
else:
|
|
# we want all scripts.
|
|
scripts = ScriptDB.objects.get_all_scripts()
|
|
if not scripts:
|
|
return
|
|
#caller.msg(scripts)
|
|
|
|
if self.switches and self.switches[0] in ('stop', 'del', 'delete'):
|
|
# we want to delete something
|
|
if not scripts:
|
|
string = "No scripts/objects matching '%s'. " % args
|
|
string += "Be more specific."
|
|
elif len(scripts) == 1:
|
|
# we have a unique match!
|
|
string = "Stopping script '%s'." % scripts[0].key
|
|
scripts[0].stop()
|
|
ScriptDB.objects.validate() #just to be sure all is synced
|
|
else:
|
|
# multiple matches.
|
|
string = "Multiple script matches. Please refine your search:\n"
|
|
string += ", ".join([str(script.key) for script in scripts])
|
|
|
|
elif self.switches and self.switches[0] in ("validate", "valid", "val"):
|
|
# run validation on all found scripts
|
|
nr_started, nr_stopped = ScriptDB.objects.validate(scripts=scripts)
|
|
string = "Validated %s scripts. " % ScriptDB.objects.all().count()
|
|
string += "Started %s and stopped %s scripts." % (nr_started,
|
|
nr_stopped)
|
|
else:
|
|
# No stopping or validation. We just want to view things.
|
|
string = format_script_list(scripts)
|
|
caller.msg(string)
|
|
|
|
|
|
class CmdListCmdSets(MuxCommand):
|
|
"""
|
|
list command sets on an object
|
|
|
|
Usage:
|
|
@listcmdsets [obj]
|
|
|
|
This displays all cmdsets assigned
|
|
to a user. Defaults to yourself.
|
|
"""
|
|
key = "@listcmdsets"
|
|
permissions = "cmd:listcmdsets"
|
|
|
|
def func(self):
|
|
"list the cmdsets"
|
|
|
|
caller = self.caller
|
|
if self.arglist:
|
|
obj = caller.search(self.arglist[0])
|
|
if not obj:
|
|
return
|
|
else:
|
|
obj = caller
|
|
string = "%s" % obj.cmdset
|
|
caller.msg(string)
|
|
|
|
class CmdListObjects(MuxCommand):
|
|
"""
|
|
List all objects in database
|
|
|
|
Usage:
|
|
@listobjects [nr]
|
|
|
|
Gives a list of nr latest objects in database ang give
|
|
statistics. If not given, nr defaults to 10.
|
|
"""
|
|
key = "@listobjects"
|
|
aliases = ["@listobj", "@listobjs"]
|
|
permissions = "cmd:listobjects"
|
|
help_category = "Building"
|
|
|
|
def func(self):
|
|
"Implement the command"
|
|
|
|
caller = self.caller
|
|
|
|
if self.args and self.args.isdigit():
|
|
nlim = int(self.args)
|
|
else:
|
|
nlim = 10
|
|
dbtotals = ObjectDB.objects.object_totals()
|
|
#print dbtotals
|
|
string = "\nObjects in database:\n"
|
|
string += "Count\tTypeclass"
|
|
for path, count in dbtotals.items():
|
|
string += "\n %s\t%s" % (count, path)
|
|
string += "\nLast %s Objects created:" % nlim
|
|
objs = list(ObjectDB.objects.all())
|
|
for i, obj in enumerate(objs):
|
|
if i <= nlim:
|
|
string += "\n %s\t%s(#%i) (%s)" % \
|
|
(obj.date_created, obj.name, obj.id, str(obj.typeclass))
|
|
else:
|
|
break
|
|
caller.msg(string)
|
|
|
|
class CmdBoot(MuxCommand):
|
|
"""
|
|
@boot
|
|
|
|
Usage
|
|
@boot[/switches] <player obj> [: reason]
|
|
|
|
Switches:
|
|
quiet - Silently boot without informing player
|
|
port - boot by port number instead of name or dbref
|
|
|
|
Boot a player object from the server. If a reason is
|
|
supplied it will be echoed to the user unless /quiet is set.
|
|
"""
|
|
|
|
key = "@boot"
|
|
permissions = "cmd:boot"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"Implementing the function"
|
|
caller = self.caller
|
|
args = self.args
|
|
|
|
if not args:
|
|
caller.msg("Usage: @boot[/switches] <player> [:reason]")
|
|
return
|
|
|
|
if ':' in args:
|
|
args, reason = [a.strip() for a in args.split(':', 1)]
|
|
boot_list = []
|
|
reason = ""
|
|
|
|
if 'port' in self.switches:
|
|
# Boot a particular port.
|
|
sessions = sessionhandler.get_session_list(True)
|
|
for sess in sessions:
|
|
# Find the session with the matching port number.
|
|
if sess.getClientAddress()[1] == int(args):
|
|
boot_list.append(sess)
|
|
break
|
|
else:
|
|
# Boot by player object
|
|
pobj = caller.search("*%s" % args, global_search=True)
|
|
if not pobj:
|
|
return
|
|
pobj = pobj[0]
|
|
if pobj.has_player:
|
|
if not has_perm(caller, pobj, 'can_boot'):
|
|
string = "You don't have the permission to boot %s."
|
|
pobj.msg(string)
|
|
return
|
|
# we have a bootable object with a connected user
|
|
matches = sessionhandler.sessions_from_object(pobj)
|
|
for match in matches:
|
|
boot_list.append(match)
|
|
else:
|
|
caller.msg("That object has no connected player.")
|
|
return
|
|
|
|
if not boot_list:
|
|
caller.msg("No matches found.")
|
|
return
|
|
|
|
# Carry out the booting of the sessions in the boot list.
|
|
|
|
feedback = None
|
|
if not 'quiet' in self.switches:
|
|
feedback = "You have been disconnected by %s.\n" % caller.name
|
|
if reason:
|
|
feedback += "\nReason given: %s" % reason
|
|
|
|
for session in boot_list:
|
|
name = session.name
|
|
if feedback:
|
|
session.msg(feedback)
|
|
session.disconnectClient()
|
|
sessionhandler.remove_session(session)
|
|
caller.msg("You booted %s." % name)
|
|
|
|
|
|
class CmdDelPlayer(MuxCommand):
|
|
"""
|
|
delplayer - delete player from server
|
|
|
|
Usage:
|
|
@delplayer[/switch] <name> [: reason]
|
|
|
|
Switch:
|
|
delobj - also delete the player's currently
|
|
assigned in-game object.
|
|
|
|
Completely deletes a user from the server database,
|
|
making their nick and e-mail again available.
|
|
"""
|
|
|
|
key = "@delplayer"
|
|
permissions = "cmd:delplayer"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"Implements the command."
|
|
|
|
caller = self.caller
|
|
args = self.args
|
|
|
|
if not args:
|
|
caller.msg("Usage: @delplayer[/delobj] <player/user name or #id>")
|
|
return
|
|
|
|
reason = ""
|
|
if ':' in args:
|
|
args, reason = [arg.strip() for arg in args.split(':', 1)]
|
|
|
|
# Search for the object connected to this user (this is done by
|
|
# adding a * to the beginning of the search criterion)
|
|
pobj = caller.search("*%s" % args, global_search=True)
|
|
if not pobj:
|
|
# if we cannot find an object connected to this user,
|
|
# try a more direct approach
|
|
try:
|
|
user = User.objects.get(id=args)
|
|
except Exception:
|
|
try:
|
|
user = User.objects.get(name__iexact=args)
|
|
except Exception:
|
|
caller.msg("Could not find user/id '%s'." % args)
|
|
return
|
|
uprofile = user.get_profile
|
|
else:
|
|
user = pobj.user
|
|
uprofile = pobj.user_profile
|
|
|
|
if not has_perm(caller, uprofile, 'manage_players'):
|
|
string = "You don't have the permissions to delete that player."
|
|
caller.msg(string)
|
|
return
|
|
|
|
uname = user.username
|
|
# boot the player then delete
|
|
if pobj and pobj.has_user:
|
|
caller.msg("Booting and informing player ...")
|
|
msg = "\nYour account '%s' is being *permanently* deleted.\n" % uname
|
|
if reason:
|
|
msg += " Reason given:\n '%s'" % reason
|
|
pobj.msg(msg)
|
|
caller.execute_cmd("@boot %s" % uname)
|
|
|
|
uprofile.delete()
|
|
user.delete()
|
|
caller.msg("Player %s was successfully deleted." % uname)
|
|
|
|
|
|
class CmdNewPassword(MuxCommand):
|
|
"""
|
|
@newpassword
|
|
|
|
Usage:
|
|
@newpassword <user obj> = <new password>
|
|
|
|
Set a player's password.
|
|
"""
|
|
|
|
key = "@newpassword"
|
|
permissions = "cmd:newpassword"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"Implement the function."
|
|
|
|
caller = self.caller
|
|
|
|
if not self.rhs:
|
|
caller.msg("Usage: @newpassword <user obj> = <new password>")
|
|
return
|
|
|
|
# the player search also matches 'me' etc.
|
|
player = caller.search("*%s" % self.lhs, global_search=True)
|
|
if not player:
|
|
return
|
|
player.user.set_password(self.rhs)
|
|
player.user.save()
|
|
caller.msg("%s - new password set to '%s'." % (player.name, self.rhs))
|
|
if player != caller:
|
|
player.msg("%s has changed your password to '%s'." % (caller.name, self.rhs))
|
|
|
|
class CmdHome(MuxCommand):
|
|
"""
|
|
home
|
|
|
|
Usage:
|
|
home
|
|
|
|
Teleport the player to their home.
|
|
"""
|
|
|
|
key = "home"
|
|
permissions = "cmd:home"
|
|
|
|
def func(self):
|
|
"Implement the command"
|
|
caller = self.caller
|
|
home = caller.home
|
|
if not home:
|
|
caller.msg("You have no home set.")
|
|
else:
|
|
caller.move_to(home)
|
|
caller.msg("There's no place like home ...")
|
|
|
|
|
|
class CmdService(MuxCommand):
|
|
"""
|
|
@service - manage services
|
|
|
|
Usage:
|
|
@service[/switch] <service>
|
|
|
|
Switches:
|
|
start - activates a service
|
|
stop - stops a service
|
|
list - shows all available services
|
|
|
|
Service management system. Allows for the listing,
|
|
starting, and stopping of services.
|
|
"""
|
|
|
|
key = "@service"
|
|
permissions = "cmd:service"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"Implement command"
|
|
|
|
caller = self.caller
|
|
switches = self.switches
|
|
|
|
if not switches or \
|
|
switches[0] not in ["list","start","stop"]:
|
|
caller.msg("Usage: @servive/<start|stop|list> [service]")
|
|
return
|
|
switch = switches[0]
|
|
|
|
# get all services
|
|
sessions = caller.sessions
|
|
if not sessions:
|
|
return
|
|
service_collection = sessions[0].server.service_collection
|
|
|
|
if switch == "list":
|
|
# Just display the list of installed services and their
|
|
# status, then exit.
|
|
string = "-" * 40
|
|
string += "\nService Listing"
|
|
|
|
for service in service_collection.services:
|
|
if service.running:
|
|
status = 'Running'
|
|
else:
|
|
status = 'Inactive'
|
|
string += '\n * %s (%s)' % (service.name, status)
|
|
string += "\n" + "-" * 40
|
|
caller.msg(string)
|
|
return
|
|
|
|
# Get the service to start / stop
|
|
|
|
try:
|
|
service = service_collection.getServiceNamed(self.args)
|
|
except Exception:
|
|
string = 'Invalid service name. This command is case-sensitive. '
|
|
string += 'See @service/list.'
|
|
caller.msg(string)
|
|
return
|
|
|
|
if switch == "stop":
|
|
# Stopping a service gracefully closes it and disconnects
|
|
# any connections (if applicable).
|
|
|
|
if not service.running:
|
|
caller.msg('That service is not currently running.')
|
|
return
|
|
# We don't want to kill the main Evennia TCPServer services
|
|
# here. If wanting to kill a listening port, one needs to
|
|
# do it through settings.py and a restart.
|
|
if service.name[:7] == 'Evennia':
|
|
string = "You can not stop Evennia TCPServer services this way."
|
|
string += "\nTo e.g. remove a listening port, change settings file and restart."
|
|
caller.msg(string)
|
|
return
|
|
#comsys.cemit_mudinfo("%s is *Stopping* the service '%s'." % (sname, service.name)) #TODO!
|
|
service.stopService()
|
|
return
|
|
|
|
if switch == "start":
|
|
#Starts a service.
|
|
if service.running:
|
|
caller.msg('That service is already running.')
|
|
return
|
|
#comsys.cemit_mudinfo("%s is *Starting* the service '%s'." % (sname,service.name)) #TODO!
|
|
service.startService()
|
|
|
|
class CmdShutdown(MuxCommand):
|
|
|
|
"""
|
|
@shutdown
|
|
|
|
Usage:
|
|
@shutdown [announcement]
|
|
|
|
Shut the game server down gracefully.
|
|
"""
|
|
key = "@shutdown"
|
|
permissions = "cmd:shutdown"
|
|
help_category = "System"
|
|
|
|
def func(self):
|
|
"Define function"
|
|
try:
|
|
session = self.caller.sessions[0]
|
|
except Exception:
|
|
return
|
|
self.caller.msg('Shutting down server ...')
|
|
announcement = "\nServer is being SHUT DOWN!\n"
|
|
if self.args:
|
|
announcement += "%s\n" % self.args
|
|
|
|
sessionhandler.announce_all(announcement)
|
|
logger.log_infomsg('Server shutdown by %s.' % self.caller.name)
|
|
|
|
# access server through session so we don't call server directly
|
|
# (importing it directly would restart it...)
|
|
session.server.shutdown()
|
|
|
|
class CmdPerm(MuxCommand):
|
|
"""
|
|
@perm - set permissions
|
|
|
|
Usage:
|
|
@perm[/switch] [<object>] = [<permission>]
|
|
@perm[/switch] [*<player>] = [<permission>]
|
|
|
|
Switches:
|
|
del : delete the given permission from <object>.
|
|
list : list all permissions, or those set on <object>
|
|
|
|
Use * before the search string to add permissions to a player.
|
|
This command sets/clears individual permission strings on an object.
|
|
Use /list without any arguments to see all available permissions
|
|
or those defined on the <object>/<player> argument.
|
|
"""
|
|
key = "@perm"
|
|
aliases = "@setperm"
|
|
permissions = "cmd:perm"
|
|
help_category = "Admin"
|
|
|
|
def func(self):
|
|
"Implement function"
|
|
|
|
caller = self.caller
|
|
switches = self.switches
|
|
lhs, rhs = self.lhs, self.rhs
|
|
|
|
if not self.args:
|
|
|
|
if "list" not in switches:
|
|
string = "Usage: @setperm[/switch] [object = permission]\n"
|
|
string +=" @setperm[/switch] [*player = permission]"
|
|
caller.msg(string)
|
|
return
|
|
else:
|
|
#just print all available permissions
|
|
string = "\nAll defined permission groups and keys (i.e. not locks):"
|
|
pgroups = list(PermissionGroup.objects.all())
|
|
pgroups.sort(lambda x,y: cmp(x.key, y.key)) # sort by group key
|
|
|
|
for pgroup in pgroups:
|
|
string += "\n\n - {w%s{n (%s):" % (pgroup.key, pgroup.desc)
|
|
string += "\n%s" % \
|
|
utils.fill(", ".join(sorted(pgroup.group_permissions)))
|
|
caller.msg(string)
|
|
return
|
|
|
|
# locate the object
|
|
obj = caller.search(self.lhs, global_search=True)
|
|
if not obj:
|
|
return
|
|
|
|
if not rhs:
|
|
string = "Permission string on {w%s{n: " % obj.key
|
|
if not obj.permissions:
|
|
string += "<None>"
|
|
else:
|
|
string += ", ".join(obj.permissions)
|
|
if obj.player and obj.player.is_superuser:
|
|
string += "\n(... But this object's player is a SUPERUSER! "
|
|
string += "All access checked are passed automatically.)"
|
|
|
|
|
|
caller.msg(string)
|
|
return
|
|
|
|
# we supplied an argument on the form obj = perm
|
|
|
|
if 'del' in switches:
|
|
# delete the given permission from object.
|
|
try:
|
|
index = obj.permissions.index(rhs)
|
|
except ValueError:
|
|
caller.msg("Permission '%s' was not defined on object." % rhs)
|
|
return
|
|
permissions = obj.permissions
|
|
del permissions[index]
|
|
obj.permissions = permissions
|
|
caller.msg("Permission '%s' was removed from object %s." % (rhs, obj.name))
|
|
obj.msg("%s revokes the permission '%s' from you." % (caller.name, rhs))
|
|
|
|
else:
|
|
# As an extra check, we warn the user if they customize the
|
|
# permission string (which is okay, and is used by the lock system)
|
|
permissions = obj.permissions
|
|
if rhs in permissions:
|
|
string = "Permission '%s' is already defined on %s." % (rhs, obj.name)
|
|
else:
|
|
permissions.append(rhs)
|
|
obj.permissions = permissions
|
|
string = "Permission '%s' given to %s." % (rhs, obj.name)
|
|
obj.msg("%s granted you the permission '%s'." % (caller.name, rhs))
|
|
caller.msg(string)
|
|
|