fluffos/testsuite/single/master.lpc

// file: /daemon/master.c

#include <globals.h>

// /inherit/master/valid.c contains all the valid_* functions
inherit "/inherit/master/valid";

nosave int has_error = 0;
nosave string last_error = "";

// Test-run statistics (gtest-style harness, see /command/tests.lpc):
// every assertion macro passes through clear_last_error(), so it doubles
// as the check counter; failed checks are RECORDED (the run continues to
// the next file) and the runner reports them all at the end.
nosave int num_checks = 0;
nosave string *test_failures = ({ });

public string clear_last_error() {
  num_checks++;
  last_error = "";
}

public void record_failure(string msg) {
  test_failures += ({ msg });
}

public int query_num_checks() { return num_checks; }

public string *query_failures() { return test_failures; }

// Remove and return the most recently recorded failure (the harness
// self-test /single/tests/std/harness.lpc uses this to probe the
// recording machinery without failing the run).
public string pop_failure() {
  string last;
  if (!sizeof(test_failures)) {
    return 0;
  }
  last = test_failures[<1];
  test_failures = test_failures[0..<2];
  return last;
}

public void reset_test_stats() {
  num_checks = 0;
  test_failures = ({ });
}

// find stack right before __assert
private mapping* trace_to_last_assert() {
  mapping *trace = dump_trace();
  for (int i = 0; i < sizeof(trace); i++) {
    if (trace[i]["function"][0..7] == "__assert") {
      return trace[0..i];
    }
  }
  return trace;
}

public string get_last_error() {
  if (last_error == "") {
    return sprintf("%O", trace_to_last_assert());
  }
  return last_error;
}

void flag(string str) {
  mixed error;
  string cmd, arg;

  if(sscanf(str, "%(test|speed):%s", cmd, arg) != 2)
    cmd = str;

  switch (cmd) {
    case "test":
      error = catch("/command/tests"->main(arg));
      if(error) {
        has_error = 1;
        write(error);
      }
      // Backstop: recorded check failures fail the run even if the
      // runner's own recap/shutdown path was skipped somehow.
      if (sizeof(test_failures)) {
        has_error = 1;
      }
      break;
    case "speed":
      error = catch("/command/speed"->main(arg));
      if(error) {
        has_error = 1;
        write(error);
      }
      shutdown(0);
      break;
    default:
      write("The only supported flag is 'test' and 'speed', got '" + str + "'.\n");
      break;
  }
  if (has_error) { shutdown(-1); }
  // otherwise wait for auto shutdown
}

void catch_tell(string str) {
   has_error = 1;
}

object connect()
{
  object login_ob;
  mixed err;

  err = catch(login_ob = new(LOGIN_OB));

  if (err) {
    write("It looks like someone is working on the player object.\n");
    write(err);
    destruct(this_object());
  }
  return login_ob;
}

// compile_object: This is used for loading MudOS "virtual" objects.
// It should return the object the mudlib wishes to associate with the
// filename named by 'file'.  It should return 0 if no object is to be
// associated.

mixed compile_object(string file)
{
    write("MASTER: compile_object is called, file : " + file + "\n");
    if (file=="/test/virtual") {
        return load_object("/single/void");
    }
    // Virtual-object fixture for the recompile_object test: any
    // /data/hu/virt* name materializes from the runtime-written
    // /data/hu/vbase source.
    if (file[0..12] == "/data/hu/virt" && file_size("/data/hu/vbase.lpc") > 0) {
        return load_object("/data/hu/vbase");
    }
    return 0;
}

// This is called when there is a driver segmentation fault or a bus error,
// etc.  As it's static it can't be called by anything but the driver (and
// master).

staticf void crash(string, object, object)
{
  foreach (object ob in users())
    tell_object(ob, "Master object shouts: Damn!\nMaster object tells you: The game is crashing.\n");
#if 0
  log_file("crashes", MUD_NAME + " crashed on: " + ctime(time()) +
      ", error: " + error + "\n");
  if (command_giver) {
    log_file("crashes", "this_player: " + file_name(command_giver) + "\n");
  }
  if (current_object) {
    log_file("crashes", "this_object: " + file_name(current_object) + "\n");
  }
#endif
}

// Function name:   update_file
// Description:     reads in a file, ignoring lines that begin with '#'
// Arguements:      file: a string that shows what file to read in.
// Return:          Array of nonblank lines that don't begin with '#'
// Note:            must be declared static (else a security hole)

staticf string *update_file(string file)
{
  string *arr;
  string str;
  int i;

  str = read_file(file);
  if (!str) {
    return ({});
  }
  arr = explode(str, "\n");
  for (i = 0; i < sizeof(arr); i++) {
    if (arr[i][0] == '#') {
      arr[i] = 0;
    }
  }
  return arr;
}

// Function name:       epilog
// Return:              List of files to preload
string* epilog(int)
{
  string *items;

  items = update_file(CONFIG_DIR + "/preload");
  return items;
}

// preload an object
void preload(string file)
{
  int t1;
  string err;

  if (file_size(file + ".lpc") == -1 && file_size(file + ".c") == -1)
    return;

  t1 = time();
  write("Preloading : " + file + "...");
  err = catch(call_other(file, "??"));
  if (err != 0) {
    write("\nError " + err + " when loading " + file + "\n");
  } else {
    t1 = time() - t1;
    write("(" + t1/60 + "." + t1 % 60 + ")\n");
  }
}

// Write an error message into a log file. The error occured in the object
// 'file', giving the error message 'message'.

void log_error(string, string message)
{
  write_file(LOG_DIR + "/compile", message);
}

// save_ed_setup and restore_ed_setup are called by the ed to maintain
// individual options settings. These functions are located in the master
// object so that the local admins can decide what strategy they want to use.

int save_ed_setup(object who, int code)
{
  string file;

  if (!intp(code)) {
    return 0;
  }
#ifdef __PACKAGE_UIDS__
  file = user_path(getuid(who)) + ".edrc";
#else
  file = "/.edrc";
#endif
  rm(file);
  return write_file(file, code + "");
}

// Retrieve the ed setup. No meaning to defend this file read from
// unauthorized access.

int retrieve_ed_setup(object who)
{
  string file;
  int code;

#ifdef __PACKAGE_UIDS__
  file = user_path(getuid(who)) + ".edrc";
#else
  file = "/.edrc";
#endif
  if (file_size(file) <= 0) {
    return 0;
  }
  sscanf(read_file(file), "%d", code);
  return code;
}

// When an object is destructed, this function is called with every
// item in that room.  We get the chance to save users from being destructed.

void destruct_environment_of(object ob)
{
  if (!interactive(ob)) {
    return;
  }
  tell_object(ob, "The object containing you was dested.\n");
  ob->move(VOID_OB);
}

// make_path_absolute: This is called by the driver to resolve path names in ed.

string make_path_absolute(string file)
{
  file = resolve_path((string)this_player()->query_cwd(), file);
  return file;
}

string get_root_uid()
{
  return ROOT_UID;
}

string get_bb_uid()
{
  return BACKBONE_UID;
}

string creator_file(string str)
{
  return (string)call_other(SINGLE_DIR + "/simul_efun", "creator_file", str);
}

string domain_file(string str)
{
  return (string)call_other(SINGLE_DIR + "/simul_efun", "domain_file", str);
}

string author_file(string str)
{
  return (string)call_other(SINGLE_DIR + "/simul_efun", "author_file", str);
}

string privs_file(string f) {
  return f;
}

staticf void error_handler(mapping map, int flag) {
  object ob;
  string str;

  /* Squelch the expected eval_cost errors thrown by the call_out tests */
  if (map["program"] == "/single/tests/efuns/call_out.lpc" &&
      map["error"] == "*Too long evaluation. Execution aborted.\n")
  {
    return;
  }

  ob = this_interactive() || this_player();

  if (flag) str = "*Error caught\n";
  else str = "";
  str += sprintf("Error: %s\nCurrent object: %O\nCurrent program: %s\nFile: %O Line: %d\n%O\n",
      map["error"], (map["object"] || "No current object"),
      (map["program"] || "No current program"),
      map["file"], map["line"],
      implode(map_array(map["trace"],
          (: sprintf("Line: %O  File: %O Object: %O Program: %O", $1["line"], $1["file"], $1["object"] || "No object", $1["program"] ||
                     "No program") :)), "\n"));
  last_error = str;
  write_file("/log/log", str);
  if (!flag && ob) tell_object(ob, str);
}

// ---------------------------------------------------------------------------
// Compile-time applies: inherit_program / include_file.
//
// The driver consults these for every `inherit "path";` statement and
// every #include directive. Returning the path unchanged keeps the
// default behavior; a different string redirects the inherit/include to
// that path; an array of strings supplies the inherited program's /
// included file's source text itself; any other value denies it.
//
// The testsuite master delegates to a registered hook object so
// individual tests (and the /single/hot_reload daemon) can observe or
// rewrite compiles while they run; with no hook registered the applies
// return the path unchanged, i.e. stock behavior. NOTE: these run in
// the middle of a compile -- a hook must never trigger another compile
// (no load_object/clone_object of unloaded files).
// ---------------------------------------------------------------------------

private object compile_hooks;

public void set_compile_hooks(object ob) { compile_hooks = ob; }

public object query_compile_hooks() { return compile_hooks; }

mixed inherit_program(string from, string path, int priv) {
  if (compile_hooks) return compile_hooks->inherit_program(from, path, priv);
  return path;
}

mixed include_file(string compiled, string from, string path) {
  if (compile_hooks) return compile_hooks->include_file(compiled, from, path);
  return path;
}

mixed get_include_path(string file)
{
  switch(file)
  {
    case "/clone/mgip1":
    case "/clone/mgip1.c":
    case "/clone/mgip1.lpc":
      return ({ "/include/m_gip1", "/include" });
    case "/clone/mgip2":
    case "/clone/mgip2.c":
    case "/clone/mgip2.lpc":
      return ({ "/include/m_gip2", "/include" });
    case "/clone/mgip3":
    case "/clone/mgip3.c":
    case "/clone/mgip3.lpc":
      return ({ "/include", "/include/m_gip1" });
    case "/clone/mgip4":
    case "/clone/mgip4.c":
    case "/clone/mgip4.lpc":
      return ({});          // should yield error message
    default:
      return ({ ":DEFAULT:" });;
  }
}

int valid_database(object ob, string action, mixed *info) {
  write("MASTER valid_database called: " + sprintf("ob:%O action:%O info:%O", ob, action, info) + "\n");

  // Approve!
  return 1;
}

// Security gate for package_ffi (op: "load"/"symbol"/"prepare"/
// "callback"). A missing apply denies by default; the testsuite allows
// everything so the ffi_* tests can exercise real native calls. A
// production master would restrict this tightly (it is a sandbox escape).
int valid_ffi(string op, mixed arg, object caller) {
  // Deny a sentinel so the denial path is testable
  // (single/tests/efuns/ffi_load.lpc).
  if (stringp(arg) && strsrch(arg, "DENY_ME") != -1) {
    return 0;
  }
  return 1;
}

string object_name(object ob) {
  return ob->name();
}