"""Miscellaneous functions for the mudpy engine."""
-# Copyright (c) 2004-2016 Jeremy Stanley <fungi@yuggoth.org>. Permission
+# Copyright (c) 2004-2017 Jeremy Stanley <fungi@yuggoth.org>. Permission
# to use, copy, modify, and distribute this software is granted under
# terms provided in the LICENSE file distributed with this software.
"""An element of the universe."""
- def __init__(self, key, universe, filename=None, old_style=False):
+ def __init__(self, key, universe, origin=None, old_style=False):
"""Set up a new element."""
# TODO(fungi): This can be removed after the transition is complete
# parse out appropriate category and subkey names, add to list
if self.key.find(":") > 0:
+ # TODO(fungi) this can be removed once old_style Elements
+ # are no longer needed
self.category, self.subkey = self.key.split(":", 1)
+ elif self.key.find(".") > 0:
+ self.category, self.subkey = self.key.split(".", 1)[-2:]
else:
self.category = "other"
self.subkey = self.key
if self.category not in self.universe.categories:
- self.category = "other"
- self.subkey = self.key
-
- # get an appropriate filename for the origin
- if not filename:
- filename = self.universe.default_origins[self.category]
- if not os.path.isabs(filename):
- filename = os.path.abspath(filename)
+ self.universe.categories[self.category] = {}
- # add the file if it doesn't exist yet
- if filename not in self.universe.files:
- mudpy.data.DataFile(filename, self.universe)
+ # get an appropriate origin
+ if not origin:
+ self.universe.add_category(self.category)
+ origin = self.universe.files[
+ self.universe.origins[self.category]["fallback"]]
# record or reset a pointer to the origin file
- self.origin = self.universe.files[filename]
-
- # add a data section to the origin if necessary
- if self.key not in self.origin.data:
- self.origin.data[self.key] = {}
+ self.origin = self.universe.files[origin.source]
# add or replace this element in the universe
self.universe.contents[self.key] = self
def reload(self):
"""Create a new element and replace this one."""
- Element(self.key, self.universe, self.origin.filename,
- old_style=self.old_style)
+ Element(self.key, self.universe, self.origin, old_style=self.old_style)
del(self)
def destroy(self):
"""Remove an element from the universe and destroy it."""
- del(self.origin.data[self.key])
+ if self.old_style:
+ del self.origin.data[self.key]
+ else:
+ for facet in self.facethash:
+ del self.origin.data[".".join((self.key, facet))]
del self.universe.categories[self.category][self.subkey]
del self.universe.contents[self.key]
del self
def set(self, facet, value):
"""Set values."""
+ if not self.origin.is_writeable() and not self.universe.loading:
+ # break if there is an attempt to update an element from a
+ # read-only file, unless the universe is in the midst of loading
+ # updated data from files
+ raise PermissionError("Altering elements in read-only files is "
+ "disallowed")
if facet in ["loglevel"]:
value = int(value)
+ elif facet in ["administrator"]:
+ value = bool(value)
if not self.has_facet(facet) or not self.get(facet) == value:
if self.old_style:
if self.key not in self.origin.data:
else:
node = ".".join((self.key, facet))
self.origin.data[node] = value
- self.facethash[node] = self.origin.data[node]
+ self.facethash[facet] = self.origin.data[node]
self.origin.modified = True
def append(self, facet, value):
"""Initialize the universe."""
self.categories = {}
self.contents = {}
- self.default_origins = {}
self.directions = set()
+ self.loading = False
self.loglines = []
- self.private_files = []
+ self.origins = {}
self.reload_flag = False
self.setup_loglines = []
self.startdir = os.getcwd()
def load(self):
"""Load universe data from persistent storage."""
+ # while loading, it's safe to update elements from read-only files
+ self.loading = True
+
# it's possible for this to enter before logging configuration is read
pending_loglines = []
del self.files[data_filename]
# start loading from the initial file
- mudpy.data.DataFile(self.filename, self)
+ mudpy.data.Data(self.filename, self)
+
+ # load default storage locations for categories
+ if hasattr(self, "contents") and "mudpy.filing" in self.contents:
+ self.origins.update(self.contents["mudpy.filing"].get(
+ "categories", {}))
+
+ # add some builtin categories we know we'll need
+ for category in ("account", "actor", "internal"):
+ self.add_category(category)
# make a list of inactive avatars
inactive_avatars = []
- for account in self.categories["account"].values():
+ for account in self.categories.get("account", {}).values():
for avatar in account.get("avatars"):
try:
inactive_avatars.append(self.contents[avatar])
for element in self.contents.values():
element.update_location()
element.clean_contents()
+
+ # done loading, so disallow updating elements from read-only files
+ self.loading = False
+
return pending_loglines
def new(self):
"""Convenience method to get the elapsed time counter."""
return self.categories["internal"]["counters"].get("elapsed")
+ def add_category(self, category, fallback=None):
+ """Set up category tracking/metadata."""
+ if category not in self.origins:
+ self.origins[category] = {}
+ if not fallback:
+ fallback = mudpy.data.find_file(
+ ".".join((category, "yaml")), universe=self)
+ if "fallback" not in self.origins[category]:
+ self.origins[category]["fallback"] = fallback
+ flags = self.origins[category].get("flags", None)
+ if fallback not in self.files:
+ mudpy.data.Data(fallback, self, flags=flags)
+
class User:
def check_idle(self):
"""Warn or disconnect idle users as appropriate."""
idletime = universe.get_time() - self.last_input
- linkdead_dict = universe.categories["internal"]["time"].get(
- "linkdead"
- )
+ linkdead_dict = universe.contents[
+ "mudpy.timing.idle.disconnect"].facets()
if self.state in linkdead_dict:
linkdead_state = self.state
else:
log(logline, 2)
self.state = "disconnecting"
self.menu_seen = False
- idle_dict = universe.categories["internal"]["time"].get("idle")
+ idle_dict = universe.contents["mudpy.timing.idle.warn"].facets()
if self.state in idle_dict:
idle_state = self.state
else:
def authenticate(self):
"""Flag the user as authenticated and disconnect duplicates."""
if self.state is not "authenticated":
- log("User " + self.account.get("name") + " logged in.", 2)
self.authenticated = True
if ("mudpy.limit" in universe.contents and self.account.subkey in
universe.contents["mudpy.limit"].get("admins")):
- self.account.set("administrator", "True")
+ self.account.set("administrator", True)
+ log("Administrator %s authenticated." %
+ self.account.get("name"), 2)
+ else:
+ # log("User %s authenticated." % self.account.get("name"), 2)
+ log("User %s authenticated." % self.account.subkey, 2)
def show_menu(self):
"""Send the user their current menu."""
counter = 0
while "avatar:" + self.account.get("name") + ":" + str(
counter
- ) in universe.categories["actor"].keys():
+ ) in universe.categories.get("actor", {}).keys():
counter += 1
self.avatar = Element(
"actor:avatar:" + self.account.get("name") + ":" + str(
replacement = replacement[:-2]
else:
replacement = ""
- log("Couldn't read included " + incfile + " file.", 6)
+ log("Couldn't read included " + incfile + " file.", 7)
# if we get here, log and replace it with null
else:
user.pulse()
# add an element for counters if it doesn't exist
- if "counters" not in universe.categories["internal"]:
- universe.categories["internal"]["counters"] = Element(
- "internal:counters", universe, old_style=True
- )
+ if "counters" not in universe.categories.get("internal", {}):
+ Element("internal:counters", universe, old_style=True)
# update the log every now and then
if not universe.categories["internal"]["counters"].get("mark"):
log(str(len(universe.userlist)) + " connection(s)")
universe.categories["internal"]["counters"].set(
- "mark", universe.categories["internal"]["time"].get(
- "frequency_log"
- )
+ "mark", universe.contents["mudpy.timing"].get("status")
)
else:
universe.categories["internal"]["counters"].set(
if not universe.categories["internal"]["counters"].get("save"):
universe.save()
universe.categories["internal"]["counters"].set(
- "save", universe.categories["internal"]["time"].get(
- "frequency_save"
- )
+ "save", universe.contents["mudpy.timing"].get("save")
)
else:
universe.categories["internal"]["counters"].set(
)
# pause for a configurable amount of time (decimal seconds)
- time.sleep(universe.categories["internal"]
- ["time"].get("increment"))
+ time.sleep(universe.contents["mudpy.timing"].get("increment"))
# increase the elapsed increment counter
universe.categories["internal"]["counters"].set(
user.error = "bad_name"
# if that account exists, time to request a password
- elif name in universe.categories["account"]:
+ elif name in universe.categories.get("account", {}):
user.account = universe.categories["account"][name]
user.state = "checking_password"
# otherwise, this could be a brand new user
else:
- user.account = Element("account:" + name, universe, old_style=True)
+ user.account = Element("account.%s" % name, universe)
user.account.set("name", name)
log("New user: " + name, 2)
user.state = "checking_new_account_name"
log(
"User " +
actor.owner.account.get("name") + " reloaded the world.",
- 8
+ 6
)
# set a flag to reload
message += "$(eol) $(grn)" + category + "$(nrm)"
elif arguments[0] == "files":
message = "These are the current files containing the universe:$(eol)"
- filenames = list(universe.files.keys())
- filenames.sort()
+ filenames = sorted(universe.files)
for filename in filenames:
if universe.files[filename].is_writeable():
status = "rw"
else:
status = "ro"
- message += ("$(eol) $(red)(" + status + ") $(grn)" + filename
- + "$(nrm)")
+ message += ("$(eol) $(red)(%s) $(grn)%s$(nrm)" %
+ (status, filename))
+ if universe.files[filename].flags:
+ message += (" $(yel)[%s]$(nrm)" %
+ ",".join(universe.files[filename].flags))
elif arguments[0] == "category":
if len(arguments) != 2:
message = "You must specify one category."
if len(arguments) != 2:
message = "You must specify one file."
elif arguments[1] in universe.files:
- message = ('These are the elements in the "' + arguments[1]
+ message = ('These are the nodes in the "' + arguments[1]
+ '" file:$(eol)')
- elements = universe.files[arguments[1]].data.keys()
- elements.sort()
+ elements = sorted(universe.files[arguments[1]].data)
for element in elements:
message += "$(eol) $(grn)" + element + "$(nrm)"
else:
- message = 'Category "' + arguments[1] + '" does not exist.'
+ message = 'File "%s" does not exist.' % arguments[1]
elif arguments[0] == "element":
if len(arguments) != 2:
message = "You must specify one element."
elif arguments[1].strip(".") in universe.contents:
element = universe.contents[arguments[1].strip(".")]
message = ('These are the properties of the "' + arguments[1]
- + '" element (in "' + element.origin.filename
+ + '" element (in "' + element.origin.source
+ '"):$(eol)')
facets = element.facets()
for facet in sorted(facets):
else:
try:
universe.contents[element].set(facet, value)
+ except PermissionError:
+ message = ('The "%s" element is kept in read-only file '
+ '"%s" and cannot be altered.' %
+ (element, universe.contents[
+ element].origin.source))
except ValueError:
message = ('Value "%s" of type "%s" cannot be coerced '
'to the correct datatype for facet "%s".' %
projects / mudpy.git / blobdiff