From: Jeremy Stanley Date: Tue, 24 Jan 2006 06:31:39 +0000 (+0000) Subject: Imported from archive. X-Git-Tag: 0.0.1~325 X-Git-Url: https://mudpy.org/gitweb?a=commitdiff_plain;h=74d37bfacdd2d7c13192fe2cd5e34f03cc2e399f;p=mudpy.git Imported from archive. * LICENSE, mudpy, mudpy.py: Updated copyright notices for 2006. * mudpy, mudpy.conf (internal:process), mudpy.py (create_pidfile) (daemonize, remove_pidfile): Implemented optional fork-and-disassociate daemon capability. * mudpy.conf (internal:network), mudpy.py (Universe.initialize_server_socket): Now, if the host facet is unset, it defaults to 0.0.0.0 (listen on all available IP interfaces). * mudpy.py (Element.clean_contents, Element.reload) (Element.update_location, Universe.load, reload_data): Additional Element methods to clean up data file reloading. (sighook): Added a signal handler to interpret hangup as if an admin had executed the reload command, and term as if the halt command had been issued. --- diff --git a/LICENSE b/LICENSE index 93116af..901a49d 100644 --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2005 mudpy, Jeremy Stanley , all rights reserved. +Copyright (c) 2006 mudpy, Jeremy Stanley , all rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: diff --git a/example/second_square/prop b/example/second_square/prop index 798b9d8..64d1fd8 100644 --- a/example/second_square/prop +++ b/example/second_square/prop @@ -1,4 +1,5 @@ [prop:fountain] impression = An inviting public fountain bubbles here, tempting you with thirst. keywords = fountain water +location = location:0,0,0 diff --git a/mudpy b/mudpy index 6b6c1c3..431c9a0 100755 --- a/mudpy +++ b/mudpy @@ -1,12 +1,33 @@ #!/usr/bin/python """Skeletal executable for the mudpy engine.""" -# Copyright (c) 2005 mudpy, Jeremy Stanley , all rights reserved. +# Copyright (c) 2006 mudpy, Jeremy Stanley , all rights reserved. # Licensed per terms in the LICENSE file distributed with this software. # core objects for the mudpy engine import mudpy -from mudpy import log, on_pulse, reload_data, universe + +# a consistent list so we can reimport these on reload +importlist = [ + "create_pidfile", + "daemonize", + "log", + "on_pulse", + "reload_data", + "remove_pidfile", + "universe" + ] +for item in importlist: exec("from mudpy import " + item) + +# log an initial message +from sys import argv +log("Started mudpy with command line: " + " ".join(argv)) + +# fork and disassociate +daemonize() + +# make the pidfile +create_pidfile(universe) # loop indefinitely while the world is not flagged for termination or # there are connected users @@ -17,6 +38,7 @@ while not universe.terminate_world or universe.userlist: # reload the mudpy module reload(mudpy) + for item in importlist: exec("from mudpy import " + item) # move data into new persistent objects reload_data() @@ -33,3 +55,6 @@ universe.save() # log a final message log("Shutting down now.") +# get rid of the pidfile +remove_pidfile(universe) + diff --git a/mudpy.conf b/mudpy.conf index 7ede114..3e85357 100644 --- a/mudpy.conf +++ b/mudpy.conf @@ -14,7 +14,7 @@ punctuation_muse = ... punctuation_say = . [internal:limits] -default_admins = admin +#default_admins = admin max_avatars = 7 password_tries = 3 @@ -28,6 +28,10 @@ stdout = yes host = port = 6669 +[internal:process] +#daemon = yes +pidfile = mudpy.pid + [internal:time] definition_d = 24h definition_h = 60mi diff --git a/mudpy.py b/mudpy.py index f5a8826..8b91054 100644 --- a/mudpy.py +++ b/mudpy.py @@ -1,15 +1,16 @@ """Core objects for the mudpy engine.""" -# Copyright (c) 2005 mudpy, Jeremy Stanley , all rights reserved. +# Copyright (c) 2006 mudpy, Jeremy Stanley , all rights reserved. # Licensed per terms in the LICENSE file distributed with this software. # import some things we need from ConfigParser import RawConfigParser from md5 import new as new_md5 -from os import R_OK, access, chmod, makedirs, stat +from os import _exit, R_OK, W_OK, access, chmod, close, fork, getpid, makedirs, remove, setsid, stat from os.path import abspath, dirname, exists, isabs, join as path_join from random import choice, randrange from re import match +from signal import SIGHUP, SIGTERM, signal from socket import AF_INET, SO_REUSEADDR, SOCK_STREAM, SOL_SOCKET, socket from stat import S_IMODE, ST_MODE from sys import stderr @@ -36,56 +37,96 @@ def excepthook(excepttype, value, traceback): import sys sys.excepthook = excepthook +def sighook(what, where): + """Handle external signals.""" + + # a generic message + message = "Caught signal: " + + # for a hangup signal + if what == SIGHUP: + message += "hangup (reloading)" + universe.reload_modules = True + + # for a terminate signal + elif what == SIGTERM: + message += "terminate (halting)" + universe.terminate_world = True + + # catchall for unexpected signals + else: message += str(what) + " (unhandled)" + + # log what happened + log(message, 8) + +# assign the sgnal handlers +signal(SIGHUP, sighook) +signal(SIGTERM, sighook) + class Element: """An element of the universe.""" def __init__(self, key, universe, filename=None): """Set up a new element.""" - # not owned by a user by default (used for avatars) - self.owner = None - - # no contents in here by default - self.contents = {} - - # an event queue for the element - self.events = {} - # keep track of our key name self.key = key - # parse out appropriate category and subkey names, add to list - if self.key.find(":") > 0: - self.category, self.subkey = self.key.split(":", 1) + # keep track of what universe it's loading` into + self.universe = universe + + # clone attributes if this is replacing another element + if self.key in self.universe.contents: + old_element = self.universe.contents[self.key] + for attribute in vars(old_element).keys(): + exec("self." + attribute + " = old_element." + attribute) + if self.owner: self.owner.avatar = self + + # i guess this is a new element then else: - self.category = "other" - self.subkey = self.key - if not self.category in universe.categories: - self.category = "other" - self.subkey = self.key - universe.categories[self.category][self.subkey] = self - # get an appropriate filename for the origin - if not filename: filename = universe.default_origins[self.category] - if not isabs(filename): filename = abspath(filename) + # not owned by a user by default (used for avatars) + self.owner = None - # add the file if it doesn't exist yet - if not filename in universe.files: DataFile(filename, universe) + # no contents in here by default + self.contents = {} + + # parse out appropriate category and subkey names, add to list + if self.key.find(":") > 0: + self.category, self.subkey = self.key.split(":", 1) + else: + self.category = "other" + self.subkey = self.key + if not self.category in self.universe.categories: + self.category = "other" + self.subkey = self.key - # record a pointer to the origin file - self.origin = universe.files[filename] + # get an appropriate filename for the origin + if not filename: filename = self.universe.default_origins[self.category] + if not isabs(filename): filename = abspath(filename) + + # add the file if it doesn't exist yet + if not filename in self.universe.files: DataFile(filename, self.universe) + + # 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 not self.origin.data.has_section(self.key): self.origin.data.add_section(self.key) - # add this element to the universe contents - universe.contents[self.key] = self + # add or replace this element in the universe + self.universe.contents[self.key] = self + self.universe.categories[self.category][self.subkey] = self + def reload(self): + """Create a new element and replace this one.""" + new_element = Element(self.key, self.universe, self.origin.filename) + del(self) def destroy(self): """Remove an element from the universe and destroy it.""" self.origin.data.remove_section(self.key) - del universe.categories[self.category][self.subkey] - del universe.contents[self.key] + del self.universe.categories[self.category][self.subkey] + del self.universe.contents[self.key] del self def facets(self): """Return a list of non-inherited facets for this element.""" @@ -105,7 +146,7 @@ class Element: if self.has_facet("inherit"): ancestry = self.getlist("inherit") for parent in ancestry[:]: - ancestors = universe.contents[parent].ancestry() + ancestors = self.universe.contents[parent].ancestry() for ancestor in ancestors: if ancestor not in ancestry: ancestry.append(ancestor) return ancestry @@ -117,8 +158,8 @@ class Element: return self.origin.data.get(self.key, facet) elif self.has_facet("inherit"): for ancestor in self.ancestry(): - if universe.contents[ancestor].has_facet(facet): - return universe.contents[ancestor].get(facet) + if self.universe.contents[ancestor].has_facet(facet): + return self.universe.contents[ancestor].get(facet) else: return default def getboolean(self, facet, default=None): """Retrieve values as boolean type.""" @@ -127,8 +168,8 @@ class Element: return self.origin.data.getboolean(self.key, facet) elif self.has_facet("inherit"): for ancestor in self.ancestry(): - if universe.contents[ancestor].has_facet(facet): - return universe.contents[ancestor].getboolean(facet) + if self.universe.contents[ancestor].has_facet(facet): + return self.universe.contents[ancestor].getboolean(facet) else: return default def getint(self, facet, default=None): """Return values as int/long type.""" @@ -137,8 +178,8 @@ class Element: return self.origin.data.getint(self.key, facet) elif self.has_facet("inherit"): for ancestor in self.ancestry(): - if universe.contents[ancestor].has_facet(facet): - return universe.contents[ancestor].getint(facet) + if self.universe.contents[ancestor].has_facet(facet): + return self.universe.contents[ancestor].getint(facet) else: return default def getfloat(self, facet, default=None): """Return values as float type.""" @@ -147,8 +188,8 @@ class Element: return self.origin.data.getfloat(self.key, facet) elif self.has_facet("inherit"): for ancestor in self.ancestry(): - if universe.contents[ancestor].has_facet(facet): - return universe.contents[ancestor].getfloat(facet) + if self.universe.contents[ancestor].has_facet(facet): + return self.universe.contents[ancestor].getfloat(facet) else: return default def getlist(self, facet, default=None): """Return values as list type.""" @@ -181,7 +222,7 @@ class Element: """Create, attach and enqueue an event element.""" # if when isn't specified, that means now - if not when: when = universe.get_time() + if not when: when = self.universe.get_time() # events are elements themselves event = Element("event:" + self.key + ":" + counter) @@ -194,7 +235,7 @@ class Element: """Check if the user can run this command object.""" # has to be in the commands category - if command not in universe.categories["command"].values(): result = False + if command not in self.universe.categories["command"].values(): result = False # avatars of administrators can run any command elif self.owner and self.owner.account.getboolean("administrator"): result = True @@ -208,13 +249,23 @@ class Element: # pass back the result return result + def update_location(self): + """Make sure the location's contents contain this element.""" + location = self.get("location") + if location in self.universe.contents: + self.universe.contents[location].contents[self.key] = self + def clean_contents(self): + """Make sure the element's contents aren't bogus.""" + for element in self.contents.values(): + if element.get("location") != self.key: + del self.contents[element.key] def go_to(self, location): """Relocate the element to a specific location.""" current = self.get("location") - if current and self.key in universe.contents[current].contents: + if current and self.key in self.universe.contents[current].contents: del universe.contents[current].contents[self.key] - if location in universe.contents: self.set("location", location) - universe.contents[location].contents[self.key] = self + if location in self.universe.contents: self.set("location", location) + self.universe.contents[location].contents[self.key] = self self.look_at(location) def go_home(self): """Relocate the element to its default location.""" @@ -222,14 +273,14 @@ class Element: self.echo_to_location("You suddenly realize that " + self.get("name") + " is here.") def move_direction(self, direction): """Relocate the element in a specified direction.""" - self.echo_to_location(self.get("name") + " exits " + universe.categories["internal"]["directions"].getdict(direction)["exit"] + ".") - self.send("You exit " + universe.categories["internal"]["directions"].getdict(direction)["exit"] + ".") - self.go_to(universe.contents[self.get("location")].link_neighbor(direction)) - self.echo_to_location(self.get("name") + " arrives from " + universe.categories["internal"]["directions"].getdict(direction)["enter"] + ".") + self.echo_to_location(self.get("name") + " exits " + self.universe.categories["internal"]["directions"].getdict(direction)["exit"] + ".") + self.send("You exit " + self.universe.categories["internal"]["directions"].getdict(direction)["exit"] + ".") + self.go_to(self.universe.contents[self.get("location")].link_neighbor(direction)) + self.echo_to_location(self.get("name") + " arrives from " + self.universe.categories["internal"]["directions"].getdict(direction)["enter"] + ".") def look_at(self, key): """Show an element to another element.""" if self.owner: - element = universe.contents[key] + element = self.universe.contents[key] message = "" name = element.get("name") if name: message += "$(cyn)" + name + "$(nrm)$(eol)" @@ -239,25 +290,27 @@ class Element: if portal_list: portal_list.sort() message += "$(cyn)[ Exits: " + ", ".join(portal_list) + " ]$(nrm)$(eol)" - for element in universe.contents[self.get("location")].contents.values(): + for element in self.universe.contents[self.get("location")].contents.values(): if element.getboolean("is_actor") and element is not self: message += "$(yel)" + element.get("name") + " is here.$(nrm)$(eol)" + elif element is not self: + message += "$(grn)" + element.get("impression") + "$(nrm)$(eol)" self.send(message) def portals(self): """Map the portal directions for a room to neighbors.""" portals = {} if match("""^location:-?\d+,-?\d+,-?\d+$""", self.key): coordinates = [(int(x)) for x in self.key.split(":")[1].split(",")] - directions = universe.categories["internal"]["directions"] + directions = self.universe.categories["internal"]["directions"] offsets = dict([(x, directions.getdict(x)["vector"]) for x in directions.facets()]) for portal in self.getlist("gridlinks"): adjacent = map(lambda c,o: c+o, coordinates, offsets[portal]) neighbor = "location:" + ",".join([(str(x)) for x in adjacent]) - if neighbor in universe.contents: portals[portal] = neighbor + if neighbor in self.universe.contents: portals[portal] = neighbor for facet in self.facets(): if facet.startswith("link_"): neighbor = self.get(facet) - if neighbor in universe.contents: + if neighbor in self.universe.contents: portal = facet.split("_")[1] portals[portal] = neighbor return portals @@ -267,7 +320,7 @@ class Element: if direction in portals: return portals[direction] def echo_to_location(self, message): """Show a message to other elements in the current location.""" - for element in universe.contents[self.get("location")].contents.values(): + for element in self.universe.contents[self.get("location")].contents.values(): if element is not self: element.send(message) class DataFile: @@ -281,6 +334,7 @@ class DataFile: self.modified = False self.data = RawConfigParser() if access(self.filename, R_OK): self.data.read(self.filename) + if not hasattr(self.universe, "files"): self.universe.files = {} self.universe.files[self.filename] = self if self.data.has_option("__control__", "include_files"): includes = makelist(self.data.get("__control__", "include_files")) @@ -321,7 +375,7 @@ class DataFile: file_descriptor = file(self.filename, "w") # if it's marked private, chmod it appropriately - if self.filename in universe.private_files and oct(S_IMODE(stat(self.filename)[ST_MODE])) != 0600: + if self.filename in self.universe.private_files and oct(S_IMODE(stat(self.filename)[ST_MODE])) != 0600: chmod(self.filename, 0600) # write it back sorted, instead of using ConfigParser @@ -347,6 +401,7 @@ class DataFile: class Universe: """The universe.""" + def __init__(self, filename=""): """Initialize the universe.""" self.categories = {} @@ -377,13 +432,48 @@ class Universe: filename = abspath(filename) self.filename = filename self.load() + def load(self): """Load universe data from persistent storage.""" - self.files = {} - DataFile(self.filename, self) + + # the files dict must exist and filename needs to be read-only + if not hasattr(self, "files") or not ( self.filename in self.files and self.files[self.filename].is_writeable() ): + + # clear out all read-only files + if hasattr(self, "files"): + for data_filename in self.files.keys(): + if not self.files[data_filename].is_writeable(): + del self.files[data_filename] + + # start loading from the initial file + DataFile(self.filename, self) + + # make a list of inactive avatars + inactive_avatars = [] + for account in self.categories["account"].values(): + inactive_avatars += [ (self.contents[x]) for x in account.getlist("avatars") ] + for user in self.userlist: + if user.avatar in inactive_avatars: + inactive_avatars.remove(user.avatar) + + # go through all elements to clear out inactive avatar locations + for element in self.contents.values(): + location = element.get("location") + if element in inactive_avatars and location: + if location in self.contents and element.key in self.contents[location].contents: + del self.contents[location].contents[element.key] + element.set("default_location", location) + element.remove_facet("location") + + # another pass to straighten out all the element contents + for element in self.contents.values(): + element.update_location() + element.clean_contents() + def save(self): """Save the universe to persistent storage.""" for key in self.files: self.files[key].save() + def initialize_server_socket(self): """Create and open the listening socket.""" @@ -396,7 +486,9 @@ class Universe: self.listening_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) # bind the socket to to our desired server ipa and port - self.listening_socket.bind((self.categories["internal"]["network"].get("host"), self.categories["internal"]["network"].getint("port"))) + host = self.categories["internal"]["network"].get("host") + port = self.categories["internal"]["network"].getint("port") + self.listening_socket.bind((host, port)) # disable blocking so we can proceed whether or not we can # send/receive @@ -406,7 +498,8 @@ class Universe: self.listening_socket.listen(1) # note that we're now ready for user connections - log("Waiting for connection(s)...") + if not host: host = "0.0.0.0" + log("Listening for Telnet connections on: " + host + ":" + str(port)) def get_time(self): """Convenience method to get the elapsed time counter.""" @@ -417,23 +510,24 @@ class User: def __init__(self): """Default values for the in-memory user variables.""" + self.account = None self.address = "" - self.last_address = "" - self.connection = None self.authenticated = False - self.password_tries = 0 - self.state = "initial" - self.menu_seen = False + self.avatar = None + self.connection = None + self.echoing = True self.error = "" self.input_queue = [] + self.last_address = "" + self.menu_choices = {} + self.menu_seen = False + self.negotiation_pause = 0 self.output_queue = [] self.partial_input = "" - self.echoing = True + self.password_tries = 0 self.received_newline = True + self.state = "initial" self.terminator = IAC+GA - self.negotiation_pause = 0 - self.avatar = None - self.account = None def quit(self): """Log, close the connection and remove.""" @@ -456,28 +550,13 @@ class User: # create a new user object new_user = User() - # set everything else equivalent - for attribute in [ - "address", - "last_address", - "connection", - "authenticated", - "password_tries", - "state", - "menu_seen", - "error", - "input_queue", - "output_queue", - "partial_input", - "echoing", - "received_newline", - "terminator", - "negotiation_pause", - "avatar", - "account" - ]: + # set everything equivalent + for attribute in vars(self).keys(): exec("new_user." + attribute + " = self." + attribute) + # the avatar needs a new owner + if new_user.avatar: new_user.avatar.owner = new_user + # add it to the list universe.userlist.append(new_user) @@ -508,7 +587,10 @@ class User: old_user.connection = self.connection old_user.last_address = old_user.address old_user.address = self.address - old_user.echoing = self.echoing + + # may need to tell the new connection to echo + if old_user.echoing: + old_user.send(get_echo_sequence(old_user.state, self.echoing), raw=True) # take this one out of the list and delete self.remove() @@ -795,6 +877,22 @@ class User: """List names of assigned avatars.""" return [ universe.contents[avatar].get("name") for avatar in self.account.getlist("avatars") ] +def create_pidfile(universe): + """Write a file containing the current process ID.""" + pid = str(getpid()) + log("Process ID: " + pid) + file_name = universe.contents["internal:process"].get("pidfile") + if file_name: + file_descriptor = file(file_name, 'w') + file_descriptor.write(pid + "\n") + file_descriptor.flush() + file_descriptor.close() + +def remove_pidfile(universe): + """Remove the file containing the current process ID.""" + file_name = universe.contents["internal:process"].get("pidfile") + if file_name and access(file_name, W_OK): remove(file_name) + def makelist(value): """Turn string into list type.""" if value[0] + value[-1] == "[]": return eval(value) @@ -1098,12 +1196,14 @@ def on_pulse(): # pause for a configurable amount of time (decimal seconds) sleep(universe.categories["internal"]["time"].getfloat("increment")) - # increment the elapsed increment counter + # increase the elapsed increment counter universe.categories["internal"]["counters"].set("elapsed", universe.categories["internal"]["counters"].getint("elapsed") + 1) def reload_data(): - """Reload data into new persistent objects.""" + """Reload all relevant objects.""" for user in universe.userlist[:]: user.reload() + for element in universe.contents.values(): + if element.origin.is_writeable(): element.reload() universe.load() def check_for_connection(listening_socket): @@ -1469,7 +1569,7 @@ def handler_active(user): elif command_name: command_error(actor, input_data) # if no input, just idle back with a prompt - else: actor("", just_prompt=True) + else: user.send("", just_prompt=True) def command_halt(actor, parameters): """Halt the world.""" @@ -1579,7 +1679,8 @@ def command_say(actor, parameters): # get rid of quote marks on the ends of the message and # capitalize the first letter - message = parameters.strip("\"'`").capitalize() + message = parameters.strip("\"'`") + message = message[0].capitalize() + message[1:] # a dictionary of punctuation:action pairs actions = {} @@ -1770,6 +1871,17 @@ def command_error(actor, input_data): # send the error message actor.send(message) +def daemonize(): + """Fork and disassociate from everything.""" + if universe.contents["internal:process"].getboolean("daemon"): + import sys + log("Disassociating from the controlling terminal.") + if fork(): _exit(0) + setsid() + for stdpipe in range(3): close(stdpipe) + sys.stdin = sys.__stdin__ = file("/dev/null", "r") + sys.stdout = sys.stderr = sys.__stdout__ = sys.__stderr__ = file("/dev/null", "w") + # if there is no universe, create an empty one if not "universe" in locals(): universe = Universe()