mirror of
https://github.com/evennia/evennia.git
synced 2026-03-19 22:36:31 +01:00
Continuing to make more methods _private to simplify API.
This commit is contained in:
Griatch
parent
c8df141e89
commit
d44dd92b5f
6 changed files with 277 additions and 268 deletions
|
|
@ -44,25 +44,29 @@ from src.commands.cmdsethandler import import_cmdset
|
|||
from src.utils import logger, utils
|
||||
from src.commands.cmdparser import at_multimatch_cmd
|
||||
|
||||
#This switches the command parser to a user-defined one.
|
||||
# You have to restart the server for this to take effect.
|
||||
COMMAND_PARSER = utils.mod_import(*settings.COMMAND_PARSER.rsplit('.', 1))
|
||||
__all__ = ("cmdhandler",)
|
||||
|
||||
# There are a few system-hardcoded command names. These
|
||||
# allow for custom behaviour when the command handler hits
|
||||
# special situations -- it then calls a normal Command
|
||||
# that you can customize!
|
||||
# Import these variables and use them rather than trying
|
||||
# to remember the actual string constants.
|
||||
# This decides which command parser is to be used.
|
||||
# You have to restart the server for changes to take effect.
|
||||
_COMMAND_PARSER = utils.mod_import(*settings.COMMAND_PARSER.rsplit('.', 1))
|
||||
|
||||
# System command names - import these variables rather than trying to
|
||||
# remember the actual string constants. If not defined, Evennia
|
||||
# hard-coded defaults are used instead.
|
||||
|
||||
# command to call if user just presses <return> with no input
|
||||
CMD_NOINPUT = "__noinput_command"
|
||||
# command to call if no command match was found
|
||||
CMD_NOMATCH = "__nomatch_command"
|
||||
# command to call if multiple command matches were found
|
||||
CMD_MULTIMATCH = "__multimatch_command"
|
||||
# command to call if found command is the name of a channel
|
||||
CMD_CHANNEL = "__send_to_channel_command"
|
||||
# this is the name of the command the engine calls when the player
|
||||
# connects. It is expected to show the login screen.
|
||||
# command to call as the very first one when the user connects.
|
||||
# (is expected to display the login screen)
|
||||
CMD_LOGINSTART = "__unloggedin_look_command"
|
||||
|
||||
# custom Exceptions
|
||||
|
||||
class NoCmdSets(Exception):
|
||||
"No cmdsets found. Critical error."
|
||||
|
|
@ -74,11 +78,15 @@ class ExecSystemCommand(Exception):
|
|||
self.syscmd = syscmd
|
||||
self.sysarg = sysarg
|
||||
|
||||
# Helper function
|
||||
|
||||
@inlineCallbacks
|
||||
def get_and_merge_cmdsets(caller):
|
||||
def _get_and_merge_cmdsets(caller):
|
||||
"""
|
||||
Gather all relevant cmdsets and merge them. Note
|
||||
that this is only relevant for logged-in callers.
|
||||
|
||||
Note that this function returns a deferred!
|
||||
"""
|
||||
# The calling object's cmdset
|
||||
try:
|
||||
|
|
@ -163,7 +171,7 @@ def cmdhandler(caller, raw_string, testing=False):
|
|||
try: # catch bugs in cmdhandler itself
|
||||
try: # catch special-type commands
|
||||
|
||||
cmdset = yield get_and_merge_cmdsets(caller)
|
||||
cmdset = yield _get_and_merge_cmdsets(caller)
|
||||
if not cmdset:
|
||||
# this is bad and shouldn't happen.
|
||||
raise NoCmdSets
|
||||
|
|
@ -177,7 +185,7 @@ def cmdhandler(caller, raw_string, testing=False):
|
|||
# Parse the input string and match to available cmdset.
|
||||
# This also checks for permissions, so all commands in match
|
||||
# are commands the caller is allowed to call.
|
||||
matches = yield COMMAND_PARSER(raw_string, cmdset, caller)
|
||||
matches = yield _COMMAND_PARSER(raw_string, cmdset, caller)
|
||||
# Deal with matches
|
||||
if not matches:
|
||||
# No commands match our entered command
|
||||
|
|
@ -302,5 +310,3 @@ def cmdhandler(caller, raw_string, testing=False):
|
|||
string += " Please contact an admin and/or file a bug report."
|
||||
logger.log_trace(string)
|
||||
caller.msg(string % format_exc())
|
||||
|
||||
#----------------------------------------------------- end cmdhandler
|
||||
|
|
|
|||
|
|
@ -16,10 +16,9 @@ together to create interesting in-game effects.
|
|||
|
||||
import copy
|
||||
from src.utils.utils import inherits_from, is_iter
|
||||
__all__ = ("CmdSet",)
|
||||
|
||||
RECURSIVE_PROTECTION = False
|
||||
|
||||
class CmdSetMeta(type):
|
||||
class _CmdSetMeta(type):
|
||||
"""
|
||||
This metaclass makes some minor on-the-fly convenience fixes to
|
||||
the cmdset class.
|
||||
|
|
@ -37,55 +36,7 @@ class CmdSetMeta(type):
|
|||
if not type(mcs.key_mergetypes) == dict:
|
||||
mcs.key_mergetypes = {}
|
||||
|
||||
super(CmdSetMeta, mcs).__init__(*args, **kwargs)
|
||||
|
||||
|
||||
# Some priority-sensitive merge operations for cmdsets
|
||||
|
||||
def union(cmdset_a, cmdset_b, duplicates=False):
|
||||
"C = A U B. CmdSet A is assumed to have higher priority"
|
||||
cmdset_c = cmdset_a.copy_this()
|
||||
# we make copies, not refs by use of [:]
|
||||
cmdset_c.commands = cmdset_a.commands[:]
|
||||
if duplicates and cmdset_a.priority == cmdset_b.priority:
|
||||
cmdset_c.commands.extend(cmdset_b.commands)
|
||||
else:
|
||||
cmdset_c.commands.extend([cmd for cmd in cmdset_b if not cmd in cmdset_a])
|
||||
return cmdset_c
|
||||
|
||||
def intersect(cmdset_a, cmdset_b, duplicates=False):
|
||||
"C = A (intersect) B. A is assumed higher priority"
|
||||
cmdset_c = cmdset_a.copy_this()
|
||||
if duplicates and cmdset_a.priority == cmdset_b.priority:
|
||||
for cmd in [cmd for cmd in cmdset_a if cmd in cmdset_b]:
|
||||
cmdset_c.add(cmd)
|
||||
cmdset_c.add(cmdset_b.get(cmd))
|
||||
else:
|
||||
cmdset_c.commands = [cmd for cmd in cmdset_a if cmd in cmdset_b]
|
||||
return cmdset_c
|
||||
|
||||
def replace(cmdset_a, cmdset_b, cmdset_c):
|
||||
"C = A + B where the result is A."
|
||||
cmdset_c = cmdset_a.copy_this()
|
||||
cmdset_c.commands = cmdset_a.commands[:]
|
||||
return cmdset_c
|
||||
|
||||
def remove(cmdset_a, cmdset_b, cmdset_c):
|
||||
"C = A + B, where B is filtered by A"
|
||||
cmdset_c = cmdset_a.copy_this()
|
||||
cmdset_c.commands = [cmd for cmd in cmdset_b if not cmd in cmdset_a]
|
||||
return cmdset_c
|
||||
|
||||
def instantiate(cmd):
|
||||
"""
|
||||
checks so that object is an instantiated command
|
||||
and not, say a cmdclass. If it is, instantiate it.
|
||||
Other types, like strings, are passed through.
|
||||
"""
|
||||
try:
|
||||
return cmd()
|
||||
except TypeError:
|
||||
return cmd
|
||||
super(_CmdSetMeta, mcs).__init__(*args, **kwargs)
|
||||
|
||||
class CmdSet(object):
|
||||
"""
|
||||
|
|
@ -166,7 +117,7 @@ class CmdSet(object):
|
|||
|
||||
|
||||
"""
|
||||
__metaclass__ = CmdSetMeta
|
||||
__metaclass__ = _CmdSetMeta
|
||||
|
||||
key = "Unnamed CmdSet"
|
||||
mergetype = "Union"
|
||||
|
|
@ -177,6 +128,9 @@ class CmdSet(object):
|
|||
no_objs = False
|
||||
no_channels = False
|
||||
permanent = False
|
||||
# pre-store properties to duplicate straight off
|
||||
to_duplicate = ("key", "cmdsetobj", "no_exits", "no_objs", "no_channels", "permanent",
|
||||
"mergetype", "priority", "duplicates")
|
||||
|
||||
def __init__(self, cmdsetobj=None, key=None):
|
||||
"""
|
||||
|
|
@ -194,127 +148,63 @@ class CmdSet(object):
|
|||
# initialize system
|
||||
self.at_cmdset_creation()
|
||||
|
||||
def at_cmdset_creation(self):
|
||||
"""
|
||||
Hook method - this should be overloaded in the inheriting
|
||||
class, and should take care of populating the cmdset
|
||||
by use of self.add().
|
||||
"""
|
||||
pass
|
||||
# Priority-sensitive merge operations for cmdsets
|
||||
|
||||
def add(self, cmd):
|
||||
"""
|
||||
Add a command, a list of commands or a cmdset to this cmdset.
|
||||
|
||||
Note that if cmd already exists in set,
|
||||
it will replace the old one (no priority checking etc
|
||||
at this point; this is often used to overload
|
||||
default commands).
|
||||
|
||||
If cmd is another cmdset class or -instance, the commands
|
||||
of that command set is added to this one, as if they were part
|
||||
of the original cmdset definition. No merging or priority checks
|
||||
are made, rather later added commands will simply replace
|
||||
existing ones to make a unique set.
|
||||
"""
|
||||
|
||||
if inherits_from(cmd, "src.commands.cmdset.CmdSet"):
|
||||
# cmd is a command set so merge all commands in that set
|
||||
# to this one. We raise a visible error if we created
|
||||
# an infinite loop (adding cmdset to itself somehow)
|
||||
try:
|
||||
cmd = instantiate(cmd)
|
||||
except RuntimeError, e:
|
||||
string = "Adding cmdset %s to %s lead to an infinite loop. When adding a cmdset to another, "
|
||||
string += "make sure they are not themself cyclically added to the new cmdset somewhere in the chain."
|
||||
raise RuntimeError(string % (cmd, self.__class__))
|
||||
cmds = cmd.commands
|
||||
elif is_iter(cmd):
|
||||
cmds = [instantiate(c) for c in cmd]
|
||||
def _union(self, cmdset_a, cmdset_b, duplicates=False):
|
||||
"C = A U B. CmdSet A is assumed to have higher priority"
|
||||
cmdset_c = cmdset_a._duplicate()
|
||||
# we make copies, not refs by use of [:]
|
||||
cmdset_c.commands = cmdset_a.commands[:]
|
||||
if duplicates and cmdset_a.priority == cmdset_b.priority:
|
||||
cmdset_c.commands.extend(cmdset_b.commands)
|
||||
else:
|
||||
cmds = [instantiate(cmd)]
|
||||
for cmd in cmds:
|
||||
# add all commands
|
||||
if not hasattr(cmd, 'obj'):
|
||||
cmd.obj = self.cmdsetobj
|
||||
try:
|
||||
ic = self.commands.index(cmd)
|
||||
self.commands[ic] = cmd # replace
|
||||
except ValueError:
|
||||
self.commands.append(cmd)
|
||||
# extra run to make sure to avoid doublets
|
||||
self.commands = list(set(self.commands))
|
||||
#print "In cmdset.add(cmd):", self.key, cmd
|
||||
cmdset_c.commands.extend([cmd for cmd in cmdset_b if not cmd in cmdset_a])
|
||||
return cmdset_c
|
||||
|
||||
def remove(self, cmd):
|
||||
"""
|
||||
Remove a command instance from the cmdset.
|
||||
cmd can be either a cmd instance or a key string.
|
||||
"""
|
||||
cmd = instantiate(cmd)
|
||||
self.commands = [oldcmd for oldcmd in self.commands if oldcmd != cmd]
|
||||
def _intersect(self, cmdset_a, cmdset_b, duplicates=False):
|
||||
"C = A (intersect) B. A is assumed higher priority"
|
||||
cmdset_c = cmdset_a._duplicate()
|
||||
if duplicates and cmdset_a.priority == cmdset_b.priority:
|
||||
for cmd in [cmd for cmd in cmdset_a if cmd in cmdset_b]:
|
||||
cmdset_c.add(cmd)
|
||||
cmdset_c.add(cmdset_b.get(cmd))
|
||||
else:
|
||||
cmdset_c.commands = [cmd for cmd in cmdset_a if cmd in cmdset_b]
|
||||
return cmdset_c
|
||||
|
||||
def get(self, cmd):
|
||||
"""
|
||||
Return the command in this cmdset that matches the
|
||||
given command. cmd may be either a command instance or
|
||||
a key string.
|
||||
"""
|
||||
cmd = instantiate(cmd)
|
||||
for thiscmd in self.commands:
|
||||
if thiscmd == cmd:
|
||||
return thiscmd
|
||||
def _replace(self, cmdset_a, cmdset_b, cmdset_c):
|
||||
"C = A + B where the result is A."
|
||||
cmdset_c = cmdset_a._duplicate()
|
||||
cmdset_c.commands = cmdset_a.commands[:]
|
||||
return cmdset_c
|
||||
|
||||
def count(self):
|
||||
"Return number of commands in set"
|
||||
return len(self.commands)
|
||||
def _remove(self, cmdset_a, cmdset_b, cmdset_c):
|
||||
"C = A + B, where B is filtered by A"
|
||||
cmdset_c = cmdset_a._duplicate()
|
||||
cmdset_c.commands = [cmd for cmd in cmdset_b if not cmd in cmdset_a]
|
||||
return cmdset_c
|
||||
|
||||
def get_system_cmds(self):
|
||||
def _instantiate(self, cmd):
|
||||
"""
|
||||
Return system commands in the cmdset, defined as
|
||||
commands starting with double underscore __.
|
||||
These are excempt from merge operations.
|
||||
checks so that object is an instantiated command
|
||||
and not, say a cmdclass. If it is, instantiate it.
|
||||
Other types, like strings, are passed through.
|
||||
"""
|
||||
return [cmd for cmd in self.commands if cmd.key.startswith('__')]
|
||||
try:
|
||||
return cmd()
|
||||
except TypeError:
|
||||
return cmd
|
||||
|
||||
def copy_this(self):
|
||||
def _duplicate(self):
|
||||
"""
|
||||
Returns a new cmdset with the same settings as this one
|
||||
(no commands are copied over)
|
||||
(no actual commands are copied over)
|
||||
"""
|
||||
cmdset = CmdSet()
|
||||
cmdset.key = self.key
|
||||
cmdset.cmdsetobj = self.cmdsetobj
|
||||
cmdset.no_exits = self.no_exits
|
||||
cmdset.no_objs = self.no_objs
|
||||
cmdset.no_channels = self.no_channels
|
||||
cmdset.mergetype = self.mergetype
|
||||
cmdset.priority = self.priority
|
||||
cmdset.duplicates = self.duplicates
|
||||
cmdset.__dict__.update(dict((key, val) for key, val in self.__dict__.items() if key in self.to_duplicate))
|
||||
cmdset.key_mergetypes = self.key_mergetypes.copy() #copy.deepcopy(self.key_mergetypes)
|
||||
return cmdset
|
||||
|
||||
def make_unique(self, caller):
|
||||
"""
|
||||
This is an unsafe command meant to clean out a cmdset of
|
||||
doublet commands after it has been created. It is useful
|
||||
for commands inheriting cmdsets from the cmdhandler where
|
||||
obj-based cmdsets always are added double. Doublets will
|
||||
be weeded out with preference to commands defined on caller,
|
||||
otherwise just by first-come-first-served.
|
||||
"""
|
||||
unique = {}
|
||||
for cmd in self.commands:
|
||||
if cmd.key in unique:
|
||||
ocmd = unique[cmd.key]
|
||||
if (hasattr(cmd, 'obj') and cmd.obj == caller) and not \
|
||||
(hasattr(ocmd, 'obj') and ocmd.obj == caller):
|
||||
unique[cmd.key] = cmd
|
||||
else:
|
||||
unique[cmd.key] = cmd
|
||||
self.commands = unique.values()
|
||||
|
||||
|
||||
def __str__(self):
|
||||
"""
|
||||
Show all commands in cmdset when printing it.
|
||||
|
|
@ -360,24 +250,24 @@ class CmdSet(object):
|
|||
# A higher or equal priority than B
|
||||
mergetype = self.key_mergetypes.get(cmdset_b.key, self.mergetype)
|
||||
if mergetype == "Intersect":
|
||||
cmdset_c = intersect(self, cmdset_b, cmdset_b.duplicates)
|
||||
cmdset_c = self._intersect(self, cmdset_b, cmdset_b.duplicates)
|
||||
elif mergetype == "Replace":
|
||||
cmdset_c = replace(self, cmdset_b, cmdset_b.duplicates)
|
||||
cmdset_c = self._replace(self, cmdset_b, cmdset_b.duplicates)
|
||||
elif mergetype == "Remove":
|
||||
cmdset_c = remove(self, cmdset_b, cmdset_b.duplicates)
|
||||
cmdset_c = self._remove(self, cmdset_b, cmdset_b.duplicates)
|
||||
else: # Union
|
||||
cmdset_c = union(self, cmdset_b, cmdset_b.duplicates)
|
||||
cmdset_c = self._union(self, cmdset_b, cmdset_b.duplicates)
|
||||
else:
|
||||
# B higher priority than A
|
||||
mergetype = cmdset_b.key_mergetypes.get(self.key, cmdset_b.mergetype)
|
||||
if mergetype == "Intersect":
|
||||
cmdset_c = intersect(cmdset_b, self, self.duplicates)
|
||||
cmdset_c = self._intersect(cmdset_b, self, self.duplicates)
|
||||
elif mergetype == "Replace":
|
||||
cmdset_c = replace(cmdset_b, self, self.duplicates)
|
||||
cmdset_c = self._replace(cmdset_b, self, self.duplicates)
|
||||
elif mergetype == "Remove":
|
||||
cmdset_c = remove(self, cmdset_b, self.duplicates)
|
||||
cmdset_c = self._remove(self, cmdset_b, self.duplicates)
|
||||
else: # Union
|
||||
cmdset_c = union(cmdset_b, self, self.duplicates)
|
||||
cmdset_c = self._union(cmdset_b, self, self.duplicates)
|
||||
|
||||
# we store actual_mergetype since key_mergetypes
|
||||
# might be different from the main mergetype.
|
||||
|
|
@ -388,3 +278,107 @@ class CmdSet(object):
|
|||
cmdset_c.add(sys_commands)
|
||||
|
||||
return cmdset_c
|
||||
|
||||
|
||||
def add(self, cmd):
|
||||
"""
|
||||
Add a command, a list of commands or a cmdset to this cmdset.
|
||||
|
||||
Note that if cmd already exists in set,
|
||||
it will replace the old one (no priority checking etc
|
||||
at this point; this is often used to overload
|
||||
default commands).
|
||||
|
||||
If cmd is another cmdset class or -instance, the commands
|
||||
of that command set is added to this one, as if they were part
|
||||
of the original cmdset definition. No merging or priority checks
|
||||
are made, rather later added commands will simply replace
|
||||
existing ones to make a unique set.
|
||||
"""
|
||||
|
||||
if inherits_from(cmd, "src.commands.cmdset.CmdSet"):
|
||||
# cmd is a command set so merge all commands in that set
|
||||
# to this one. We raise a visible error if we created
|
||||
# an infinite loop (adding cmdset to itself somehow)
|
||||
try:
|
||||
cmd = self._instantiate(cmd)
|
||||
except RuntimeError, e:
|
||||
string = "Adding cmdset %s to %s lead to an infinite loop. When adding a cmdset to another, "
|
||||
string += "make sure they are not themself cyclically added to the new cmdset somewhere in the chain."
|
||||
raise RuntimeError(string % (cmd, self.__class__))
|
||||
cmds = cmd.commands
|
||||
elif is_iter(cmd):
|
||||
cmds = [self._instantiate(c) for c in cmd]
|
||||
else:
|
||||
cmds = [self._instantiate(cmd)]
|
||||
for cmd in cmds:
|
||||
# add all commands
|
||||
if not hasattr(cmd, 'obj'):
|
||||
cmd.obj = self.cmdsetobj
|
||||
try:
|
||||
ic = self.commands.index(cmd)
|
||||
self.commands[ic] = cmd # replace
|
||||
except ValueError:
|
||||
self.commands.append(cmd)
|
||||
# extra run to make sure to avoid doublets
|
||||
self.commands = list(set(self.commands))
|
||||
#print "In cmdset.add(cmd):", self.key, cmd
|
||||
|
||||
def remove(self, cmd):
|
||||
"""
|
||||
Remove a command instance from the cmdset.
|
||||
cmd can be either a cmd instance or a key string.
|
||||
"""
|
||||
cmd = self._instantiate(cmd)
|
||||
self.commands = [oldcmd for oldcmd in self.commands if oldcmd != cmd]
|
||||
|
||||
def get(self, cmd):
|
||||
"""
|
||||
Return the command in this cmdset that matches the
|
||||
given command. cmd may be either a command instance or
|
||||
a key string.
|
||||
"""
|
||||
cmd = self._instantiate(cmd)
|
||||
for thiscmd in self.commands:
|
||||
if thiscmd == cmd:
|
||||
return thiscmd
|
||||
|
||||
def count(self):
|
||||
"Return number of commands in set"
|
||||
return len(self.commands)
|
||||
|
||||
def get_system_cmds(self):
|
||||
"""
|
||||
Return system commands in the cmdset, defined as
|
||||
commands starting with double underscore __.
|
||||
These are excempt from merge operations.
|
||||
"""
|
||||
return [cmd for cmd in self.commands if cmd.key.startswith('__')]
|
||||
|
||||
def make_unique(self, caller):
|
||||
"""
|
||||
This is an unsafe command meant to clean out a cmdset of
|
||||
doublet commands after it has been created. It is useful
|
||||
for commands inheriting cmdsets from the cmdhandler where
|
||||
obj-based cmdsets always are added double. Doublets will
|
||||
be weeded out with preference to commands defined on caller,
|
||||
otherwise just by first-come-first-served.
|
||||
"""
|
||||
unique = {}
|
||||
for cmd in self.commands:
|
||||
if cmd.key in unique:
|
||||
ocmd = unique[cmd.key]
|
||||
if (hasattr(cmd, 'obj') and cmd.obj == caller) and not \
|
||||
(hasattr(ocmd, 'obj') and ocmd.obj == caller):
|
||||
unique[cmd.key] = cmd
|
||||
else:
|
||||
unique[cmd.key] = cmd
|
||||
self.commands = unique.values()
|
||||
|
||||
def at_cmdset_creation(self):
|
||||
"""
|
||||
Hook method - this should be overloaded in the inheriting
|
||||
class, and should take care of populating the cmdset
|
||||
by use of self.add().
|
||||
"""
|
||||
pass
|
||||
|
|
|
|||
|
|
@ -67,8 +67,9 @@ import traceback
|
|||
from src.utils import logger, utils
|
||||
from src.commands.cmdset import CmdSet
|
||||
from src.server.models import ServerConfig
|
||||
__all__ = ("import_cmdset", "CmdSetHandler")
|
||||
|
||||
CACHED_CMDSETS = {}
|
||||
_CACHED_CMDSETS = {}
|
||||
|
||||
def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
|
||||
"""
|
||||
|
|
@ -87,9 +88,9 @@ def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
|
|||
|
||||
try:
|
||||
try:
|
||||
#print "importing %s: CACHED_CMDSETS=%s" % (python_path, CACHED_CMDSETS)
|
||||
#print "importing %s: _CACHED_CMDSETS=%s" % (python_path, _CACHED_CMDSETS)
|
||||
wanted_cache_key = python_path
|
||||
cmdsetclass = CACHED_CMDSETS.get(wanted_cache_key, None)
|
||||
cmdsetclass = _CACHED_CMDSETS.get(wanted_cache_key, None)
|
||||
errstring = ""
|
||||
if not cmdsetclass:
|
||||
#print "cmdset '%s' not in cache. Reloading %s on %s." % (wanted_cache_key, python_path, cmdsetobj)
|
||||
|
|
@ -97,7 +98,7 @@ def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
|
|||
modulepath, classname = python_path.rsplit('.', 1)
|
||||
module = __import__(modulepath, fromlist=[True])
|
||||
cmdsetclass = module.__dict__[classname]
|
||||
CACHED_CMDSETS[wanted_cache_key] = cmdsetclass
|
||||
_CACHED_CMDSETS[wanted_cache_key] = cmdsetclass
|
||||
#instantiate the cmdset (and catch its errors)
|
||||
if callable(cmdsetclass):
|
||||
cmdsetclass = cmdsetclass(cmdsetobj)
|
||||
|
|
@ -115,13 +116,15 @@ def import_cmdset(python_path, cmdsetobj, emit_to_obj=None, no_logging=False):
|
|||
errstring = "\n%s\nCompile/Run error when loading cmdset '%s'."
|
||||
errstring = errstring % (traceback.format_exc(), python_path)
|
||||
raise
|
||||
except Exception:
|
||||
except Exception, e:
|
||||
if errstring and not no_logging:
|
||||
print errstring
|
||||
logger.log_trace()
|
||||
if emit_to_obj and not ServerConfig.objects.conf("server_starting_mode"):
|
||||
object.__getattribute__(emit_to_obj, "msg")(errstring)
|
||||
logger.log_errmsg("Error: %s" % errstring)
|
||||
if not errstring:
|
||||
errstring = "Error in import cmdset: %s" % e
|
||||
logger.log_errmsg(errstring)
|
||||
#cannot raise - it kills the server if no base cmdset exists!
|
||||
|
||||
# classes
|
||||
|
|
@ -198,6 +201,17 @@ class CmdSetHandler(object):
|
|||
", ".join(cmd.key for cmd in sorted(self.current, key=lambda o:o.key)))
|
||||
return string.strip()
|
||||
|
||||
def _import_cmdset(self, cmdset_path, emit_to_obj=None):
|
||||
"""
|
||||
Method wrapper for import_cmdset.
|
||||
load a cmdset from a module.
|
||||
cmdset_path - the python path to an cmdset object.
|
||||
emit_to_obj - object to send error messages to
|
||||
"""
|
||||
if not emit_to_obj:
|
||||
emit_to_obj = self.obj
|
||||
return import_cmdset(cmdset_path, self.obj, emit_to_obj)
|
||||
|
||||
def update(self, init_mode=False):
|
||||
"""
|
||||
Re-adds all sets in the handler to have an updated
|
||||
|
|
@ -216,7 +230,7 @@ class CmdSetHandler(object):
|
|||
if pos == 0 and not path:
|
||||
self.cmdset_stack = [CmdSet(cmdsetobj=self.obj, key="Empty")]
|
||||
elif path:
|
||||
cmdset = self.import_cmdset(path)
|
||||
cmdset = self._import_cmdset(path)
|
||||
if cmdset:
|
||||
cmdset.permanent = True
|
||||
self.cmdset_stack.append(cmdset)
|
||||
|
|
@ -233,17 +247,6 @@ class CmdSetHandler(object):
|
|||
self.mergetype_stack.append(new_current.actual_mergetype)
|
||||
self.current = new_current
|
||||
|
||||
def import_cmdset(self, cmdset_path, emit_to_obj=None):
|
||||
"""
|
||||
Method wrapper for import_cmdset.
|
||||
load a cmdset from a module.
|
||||
cmdset_path - the python path to an cmdset object.
|
||||
emit_to_obj - object to send error messages to
|
||||
"""
|
||||
if not emit_to_obj:
|
||||
emit_to_obj = self.obj
|
||||
return import_cmdset(cmdset_path, self.obj, emit_to_obj)
|
||||
|
||||
def add(self, cmdset, emit_to_obj=None, permanent=False):
|
||||
"""
|
||||
Add a cmdset to the handler, on top of the old ones.
|
||||
|
|
@ -271,7 +274,7 @@ class CmdSetHandler(object):
|
|||
cmdset = cmdset(self.obj)
|
||||
elif isinstance(cmdset, basestring):
|
||||
# this is (maybe) a python path. Try to import from cache.
|
||||
cmdset = self.import_cmdset(cmdset)
|
||||
cmdset = self._import_cmdset(cmdset)
|
||||
if cmdset:
|
||||
if permanent:
|
||||
# store the path permanently
|
||||
|
|
@ -303,7 +306,7 @@ class CmdSetHandler(object):
|
|||
cmdset = cmdset(self.obj)
|
||||
elif isinstance(cmdset, basestring):
|
||||
# this is (maybe) a python path. Try to import from cache.
|
||||
cmdset = self.import_cmdset(cmdset)
|
||||
cmdset = self._import_cmdset(cmdset)
|
||||
if cmdset:
|
||||
if self.cmdset_stack:
|
||||
self.cmdset_stack[0] = cmdset
|
||||
|
|
@ -430,7 +433,7 @@ class CmdSetHandler(object):
|
|||
def reset(self):
|
||||
"""
|
||||
Force reload of all cmdsets in handler. This should be called
|
||||
after CACHED_CMDSETS have been cleared (normally by @reload).
|
||||
after _CACHED_CMDSETS have been cleared (normally by @reload).
|
||||
"""
|
||||
new_cmdset_stack = []
|
||||
new_mergetype_stack = []
|
||||
|
|
@ -439,7 +442,7 @@ class CmdSetHandler(object):
|
|||
new_cmdset_stack.append(cmdset)
|
||||
new_mergetype_stack.append("Union")
|
||||
else:
|
||||
new_cmdset_stack.append(self.import_cmdset(cmdset.path))
|
||||
new_cmdset_stack.append(self._import_cmdset(cmdset.path))
|
||||
new_mergetype_stack.append(cmdset.mergetype)
|
||||
self.cmdset_stack = new_cmdset_stack
|
||||
self.mergetype_stack = new_mergetype_stack
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ from src.locks.lockhandler import LockHandler
|
|||
from src.utils import logger
|
||||
from src.utils.utils import is_iter, to_str
|
||||
from src.utils.utils import dbref as is_dbref
|
||||
|
||||
__all__ = ("Msg", "TempMsg", "Channel", "PlayerChannelConnection", "ExternalChannelConnection")
|
||||
|
||||
#------------------------------------------------------------
|
||||
#
|
||||
|
|
@ -29,7 +29,7 @@ from src.utils.utils import dbref as is_dbref
|
|||
#
|
||||
#------------------------------------------------------------
|
||||
|
||||
def obj_to_id(inp):
|
||||
def _obj_to_id(inp):
|
||||
"""
|
||||
Converts input object to an id string.
|
||||
"""
|
||||
|
|
@ -42,7 +42,7 @@ def obj_to_id(inp):
|
|||
return str(inp.dbobj.id)
|
||||
return str(inp)
|
||||
|
||||
def id_to_obj(dbref, db_model='PlayerDB'):
|
||||
def _id_to_obj(dbref, db_model='PlayerDB'):
|
||||
"""
|
||||
loads from dbref to object. Uses the db_model to search
|
||||
for the id.
|
||||
|
|
@ -140,186 +140,186 @@ class Msg(SharedMemoryModel):
|
|||
|
||||
# sender property (wraps db_sender)
|
||||
#@property
|
||||
def sender_get(self):
|
||||
def __sender_get(self):
|
||||
"Getter. Allows for value = self.sender"
|
||||
return self.db_sender
|
||||
#@sender.setter
|
||||
def sender_set(self, value):
|
||||
def __sender_set(self, value):
|
||||
"Setter. Allows for self.sender = value"
|
||||
self.db_sender = value
|
||||
self.save()
|
||||
#@sender.deleter
|
||||
def sender_del(self):
|
||||
def __sender_del(self):
|
||||
"Deleter. Allows for del self.sender"
|
||||
raise Exception("You cannot delete the sender of a message!")
|
||||
sender = property(sender_get, sender_set, sender_del)
|
||||
sender = property(__sender_get, __sender_set, __sender_del)
|
||||
|
||||
# sender_external property (wraps db_sender_external)
|
||||
#@property
|
||||
def sender_external_get(self):
|
||||
def __sender_external_get(self):
|
||||
"Getter. Allows for value = self.sender_external"
|
||||
return self.db_sender_external
|
||||
#@sender_external.setter
|
||||
def sender_external_set(self, value):
|
||||
def __sender_external_set(self, value):
|
||||
"Setter. Allows for self.sender_external = value"
|
||||
self.db_sender_external = value
|
||||
self.save()
|
||||
#@sender_external.deleter
|
||||
def sender_external_del(self):
|
||||
def __sender_external_del(self):
|
||||
"Deleter. Allows for del self.sender_external"
|
||||
raise Exception("You cannot delete the sender_external of a message!")
|
||||
sender_external = property(sender_external_get, sender_external_set, sender_external_del)
|
||||
sender_external = property(__sender_external_get, __sender_external_set, __sender_external_del)
|
||||
|
||||
# receivers property
|
||||
#@property
|
||||
def receivers_get(self):
|
||||
def __receivers_get(self):
|
||||
"Getter. Allows for value = self.receivers. Returns a list of receivers."
|
||||
if self.db_receivers:
|
||||
return [id_to_obj(dbref) for dbref in self.db_receivers.split(',')]
|
||||
return [_id_to_obj(dbref) for dbref in self.db_receivers.split(',')]
|
||||
return []
|
||||
#@receivers.setter
|
||||
def receivers_set(self, value):
|
||||
def __receivers_set(self, value):
|
||||
"Setter. Allows for self.receivers = value. Stores as a comma-separated string."
|
||||
if is_iter(value):
|
||||
value = ",".join([obj_to_id(val) for val in value])
|
||||
self.db_receivers = obj_to_id(value)
|
||||
value = ",".join([_obj_to_id(val) for val in value])
|
||||
self.db_receivers = _obj_to_id(value)
|
||||
self.save()
|
||||
#@receivers.deleter
|
||||
def receivers_del(self):
|
||||
def __receivers_del(self):
|
||||
"Deleter. Allows for del self.receivers"
|
||||
self.db_receivers = ""
|
||||
self.save()
|
||||
receivers = property(receivers_get, receivers_set, receivers_del)
|
||||
receivers = property(__receivers_get, __receivers_set, __receivers_del)
|
||||
|
||||
# channels property
|
||||
#@property
|
||||
def channels_get(self):
|
||||
def __channels_get(self):
|
||||
"Getter. Allows for value = self.channels. Returns a list of channels."
|
||||
if self.db_channels:
|
||||
return [id_to_obj(dbref, 'Channel') for dbref in self.db_channels.split(',')]
|
||||
return [_id_to_obj(dbref, 'Channel') for dbref in self.db_channels.split(',')]
|
||||
return []
|
||||
#@channels.setter
|
||||
def channels_set(self, value):
|
||||
def __channels_set(self, value):
|
||||
"Setter. Allows for self.channels = value. Stores as a comma-separated string."
|
||||
if is_iter(value):
|
||||
value = ",".join([obj_to_id(val) for val in value])
|
||||
self.db_channels = obj_to_id(value)
|
||||
value = ",".join([_obj_to_id(val) for val in value])
|
||||
self.db_channels = _obj_to_id(value)
|
||||
self.save()
|
||||
#@channels.deleter
|
||||
def channels_del(self):
|
||||
def __channels_del(self):
|
||||
"Deleter. Allows for del self.channels"
|
||||
self.db_channels = ""
|
||||
self.save()
|
||||
channels = property(channels_get, channels_set, channels_del)
|
||||
channels = property(__channels_get, __channels_set, __channels_del)
|
||||
|
||||
# message property (wraps db_message)
|
||||
#@property
|
||||
def message_get(self):
|
||||
def __message_get(self):
|
||||
"Getter. Allows for value = self.message"
|
||||
return self.db_message
|
||||
#@message.setter
|
||||
def message_set(self, value):
|
||||
def __message_set(self, value):
|
||||
"Setter. Allows for self.message = value"
|
||||
self.db_message = value
|
||||
self.save()
|
||||
#@message.deleter
|
||||
def message_del(self):
|
||||
def __message_del(self):
|
||||
"Deleter. Allows for del self.message"
|
||||
self.db_message = ""
|
||||
self.save()
|
||||
message = property(message_get, message_set, message_del)
|
||||
message = property(__message_get, __message_set, __message_del)
|
||||
|
||||
# date_sent property (wraps db_date_sent)
|
||||
#@property
|
||||
def date_sent_get(self):
|
||||
def __date_sent_get(self):
|
||||
"Getter. Allows for value = self.date_sent"
|
||||
return self.db_date_sent
|
||||
#@date_sent.setter
|
||||
def date_sent_set(self, value):
|
||||
def __date_sent_set(self, value):
|
||||
"Setter. Allows for self.date_sent = value"
|
||||
raise Exception("You cannot edit date_sent!")
|
||||
#@date_sent.deleter
|
||||
def date_sent_del(self):
|
||||
def __date_sent_del(self):
|
||||
"Deleter. Allows for del self.date_sent"
|
||||
raise Exception("You cannot delete the date_sent property!")
|
||||
date_sent = property(date_sent_get, date_sent_set, date_sent_del)
|
||||
date_sent = property(__date_sent_get, __date_sent_set, __date_sent_del)
|
||||
|
||||
# hide_from_sender property
|
||||
#@property
|
||||
def hide_from_sender_get(self):
|
||||
def __hide_from_sender_get(self):
|
||||
"Getter. Allows for value = self.hide_from_sender."
|
||||
return self.db_hide_from_sender
|
||||
#@hide_from_sender.setter
|
||||
def hide_from_sender_set(self, value):
|
||||
def __hide_from_sender_set(self, value):
|
||||
"Setter. Allows for self.hide_from_senders = value."
|
||||
self.db_hide_from_sender = value
|
||||
self.save()
|
||||
#@hide_from_sender.deleter
|
||||
def hide_from_sender_del(self):
|
||||
def __hide_from_sender_del(self):
|
||||
"Deleter. Allows for del self.hide_from_senders"
|
||||
self.db_hide_from_sender = False
|
||||
self.save()
|
||||
hide_from_sender = property(hide_from_sender_get, hide_from_sender_set, hide_from_sender_del)
|
||||
hide_from_sender = property(__hide_from_sender_get, __hide_from_sender_set, __hide_from_sender_del)
|
||||
|
||||
# hide_from_receivers property
|
||||
#@property
|
||||
def hide_from_receivers_get(self):
|
||||
def __hide_from_receivers_get(self):
|
||||
"Getter. Allows for value = self.hide_from_receivers. Returns a list of hide_from_receivers."
|
||||
if self.db_hide_from_receivers:
|
||||
return [id_to_obj(dbref) for dbref in self.db_hide_from_receivers.split(',')]
|
||||
return [_id_to_obj(dbref) for dbref in self.db_hide_from_receivers.split(',')]
|
||||
return []
|
||||
#@hide_from_receivers.setter
|
||||
def hide_from_receivers_set(self, value):
|
||||
def __hide_from_receivers_set(self, value):
|
||||
"Setter. Allows for self.hide_from_receivers = value. Stores as a comma-separated string."
|
||||
if is_iter(value):
|
||||
value = ",".join([obj_to_id(val) for val in value])
|
||||
self.db_hide_from_receivers = obj_to_id(value)
|
||||
value = ",".join([_obj_to_id(val) for val in value])
|
||||
self.db_hide_from_receivers = _obj_to_id(value)
|
||||
self.save()
|
||||
#@hide_from_receivers.deleter
|
||||
def hide_from_receivers_del(self):
|
||||
def __hide_from_receivers_del(self):
|
||||
"Deleter. Allows for del self.hide_from_receivers"
|
||||
self.db_hide_from_receivers = ""
|
||||
self.save()
|
||||
hide_from_receivers = property(hide_from_receivers_get, hide_from_receivers_set, hide_from_receivers_del)
|
||||
hide_from_receivers = property(__hide_from_receivers_get, __hide_from_receivers_set, __hide_from_receivers_del)
|
||||
|
||||
# hide_from_channels property
|
||||
#@property
|
||||
def hide_from_channels_get(self):
|
||||
def __hide_from_channels_get(self):
|
||||
"Getter. Allows for value = self.hide_from_channels. Returns a list of hide_from_channels."
|
||||
if self.db_hide_from_channels:
|
||||
return [id_to_obj(dbref) for dbref in self.db_hide_from_channels.split(',')]
|
||||
return [_id_to_obj(dbref) for dbref in self.db_hide_from_channels.split(',')]
|
||||
return []
|
||||
#@hide_from_channels.setter
|
||||
def hide_from_channels_set(self, value):
|
||||
def __hide_from_channels_set(self, value):
|
||||
"Setter. Allows for self.hide_from_channels = value. Stores as a comma-separated string."
|
||||
if is_iter(value):
|
||||
value = ",".join([obj_to_id(val) for val in value])
|
||||
self.db_hide_from_channels = obj_to_id(value)
|
||||
value = ",".join([_obj_to_id(val) for val in value])
|
||||
self.db_hide_from_channels = _obj_to_id(value)
|
||||
self.save()
|
||||
#@hide_from_channels.deleter
|
||||
def hide_from_channels_del(self):
|
||||
def __hide_from_channels_del(self):
|
||||
"Deleter. Allows for del self.hide_from_channels"
|
||||
self.db_hide_from_channels = ""
|
||||
self.save()
|
||||
hide_from_channels = property(hide_from_channels_get, hide_from_channels_set, hide_from_channels_del)
|
||||
hide_from_channels = property(__hide_from_channels_get, __hide_from_channels_set, __hide_from_channels_del)
|
||||
|
||||
# lock_storage property (wraps db_lock_storage)
|
||||
#@property
|
||||
def lock_storage_get(self):
|
||||
def __lock_storage_get(self):
|
||||
"Getter. Allows for value = self.lock_storage"
|
||||
return self.db_lock_storage
|
||||
#@nick.setter
|
||||
def lock_storage_set(self, value):
|
||||
def __lock_storage_set(self, value):
|
||||
"""Saves the lock_storagetodate. This is usually not called directly, but through self.lock()"""
|
||||
self.db_lock_storage = value
|
||||
self.save()
|
||||
#@nick.deleter
|
||||
def lock_storage_del(self):
|
||||
def __lock_storage_del(self):
|
||||
"Deleter is disabled. Use the lockhandler.delete (self.lock.delete) instead"""
|
||||
logger.log_errmsg("Lock_Storage (on %s) cannot be deleted. Use obj.lock.delete() instead." % self)
|
||||
lock_storage = property(lock_storage_get, lock_storage_set, lock_storage_del)
|
||||
lock_storage = property(__lock_storage_get, __lock_storage_set, __lock_storage_del)
|
||||
|
||||
db_model_name = "msg" # used by attributes to safely store objects
|
||||
_db_model_name = "msg" # used by attributes to safely store objects
|
||||
|
||||
#
|
||||
# Msg class methods
|
||||
|
|
|
|||
|
|
@ -72,6 +72,9 @@ class HelpEntry(SharedMemoryModel):
|
|||
verbose_name = "Help Entry"
|
||||
verbose_name_plural = "Help Entries"
|
||||
|
||||
# used by Attributes to safely retrieve stored object
|
||||
_db_model_name = "helpentry"
|
||||
|
||||
# Wrapper properties to easily set database fields. These are
|
||||
# @property decorators that allows to access these fields using
|
||||
# normal python operations (without having to remember to save()
|
||||
|
|
|
|||
|
|
@ -51,6 +51,9 @@ class ServerConfig(SharedMemoryModel):
|
|||
|
||||
objects = ServerConfigManager()
|
||||
|
||||
# used by Attributes eventually storing this safely
|
||||
_db_model_name = "serverconfig"
|
||||
|
||||
# Wrapper properties to easily set database fields. These are
|
||||
# @property decorators that allows to access these fields using
|
||||
# normal python operations (without having to remember to save()
|
||||
|
|
@ -61,27 +64,27 @@ class ServerConfig(SharedMemoryModel):
|
|||
|
||||
# key property (wraps db_key)
|
||||
#@property
|
||||
def key_get(self):
|
||||
def __key_get(self):
|
||||
"Getter. Allows for value = self.key"
|
||||
return self.db_key
|
||||
#@key.setter
|
||||
def key_set(self, value):
|
||||
def __key_set(self, value):
|
||||
"Setter. Allows for self.key = value"
|
||||
self.db_key = value
|
||||
self.save()
|
||||
#@key.deleter
|
||||
def key_del(self):
|
||||
def __key_del(self):
|
||||
"Deleter. Allows for del self.key. Deletes entry."
|
||||
self.delete()
|
||||
key = property(key_get, key_set, key_del)
|
||||
key = property(__key_get, __key_set, __key_del)
|
||||
|
||||
# value property (wraps db_value)
|
||||
#@property
|
||||
def value_get(self):
|
||||
def __value_get(self):
|
||||
"Getter. Allows for value = self.value"
|
||||
return pickle.loads(str(self.db_value))
|
||||
#@value.setter
|
||||
def value_set(self, value):
|
||||
def __value_set(self, value):
|
||||
"Setter. Allows for self.value = value"
|
||||
if utils.has_parent('django.db.models.base.Model', value):
|
||||
# we have to protect against storing db objects.
|
||||
|
|
@ -90,10 +93,10 @@ class ServerConfig(SharedMemoryModel):
|
|||
self.db_value = pickle.dumps(value)
|
||||
self.save()
|
||||
#@value.deleter
|
||||
def value_del(self):
|
||||
def __value_del(self):
|
||||
"Deleter. Allows for del self.value. Deletes entry."
|
||||
self.delete()
|
||||
value = property(value_get, value_set, value_del)
|
||||
value = property(__value_get, __value_set, __value_del)
|
||||
|
||||
class Meta:
|
||||
"Define Django meta options"
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue