Your own service

-- visitors: a service that keeps a log of every creature the motion sensor sees, with the world's
-- date and time, a line each, in /home/visitors.log. It runs in the background as a service (rc
-- visitors start), and ends cleanly when stopped (rc sends SIGTERM).
local sys = require("sys")

local LOG = "/home/visitors.log"

local sensor = assert(io.open("/dev/motion0"))

-- rc's stop: say so in the log, and end.
sys.signal("SIGTERM", function()
  local log = io.open(LOG, "a")
  log:write(os.date("%c"), " stopped\n")
  log:close()
  os.exit(0)
end)

-- Each event, a line: "minecraft:pig 1.5 0.0 -3.0" (what, and where from the sensor).
for line in sensor:lines() do
  local mob = line:match("^(%S+)")
  -- Opened and closed each time: a file on a disk shows what's written only once it's closed.
  local log = assert(io.open(LOG, "a"))
  log:write(os.date("%c"), " ", mob, "\n")
  log:close()
end

-- /etc/rc.d/visitors: the visitors service's definition, for rc. Its settings are all it needs:
-- rc starts the command in the background, keeps its pid in /run/visitors.pid, and stops it.
description = "logs what the motion sensor sees"
command = "/bin/lua"
command_args = {"/home/visitors.lua"}
output_log = "/tmp/visitors.log"

-- /etc/rc.d/visitors, every action written out: what rc does for a service when its definition
-- only sets command (start, stop, restart, status), done here by the service's own functions, and
-- an action of its own (rc visitors count). rc runs the one named; a function this file doesn't
-- define, rc does itself. 'name' is the service's name (visitors), set by rc.
local sys = require("sys")

description = "logs what the motion sensor sees"
command = "/bin/lua"
command_args = {"/home/visitors.lua"}
output_log = "/tmp/visitors.out"

local LOG = "/home/visitors.log" -- what the program writes
local PIDFILE = "/run/" .. name .. ".pid"
local STOP_SECONDS = 5 -- how long it has to end after SIGTERM, before SIGKILL
local STOP_POLL = 0.1
local NOT_RUNNING = 3 -- status's answer when it isn't running (LSB's)

-- Its process id while it runs, from its pid file; else nil.
local function running()
  local file = io.open(PIDFILE)
  if not file then
    return nil
  end
  local pid = math.tointeger(tonumber(file:read("l") or ""))
  file:close()
  for _, process in ipairs(sys.processes()) do
    if process.pid == pid and process.state ~= "zombie" then
      return pid
    end
  end
end

-- rc visitors start: runs it as a daemon (a session of its own, so no terminal's Ctrl+C reaches it;
-- its input /dev/null, its output and errors to output_log), its pid in /run/visitors.pid.
function start()
  if running() then
    print(name .. " is already running")
    return 0
  end
  local null = assert(sys.open("/dev/null"))
  local out = assert(sys.open(output_log, "a"))
  local pid = assert(sys.spawn(command, command_args, {setsid = true, fds = {[0] = null, [1] = out, [2] = out}}))
  sys.close(null)
  sys.close(out)
  local file = assert(io.open(PIDFILE, "w"))
  file:write(pid, "\n")
  file:close()
  return 0
end

-- rc visitors stop: SIGTERM, then SIGKILL if it hasn't ended in STOP_SECONDS.
function stop()
  local pid = running()
  if not pid then
    print(name .. " is not running")
    return 0
  end
  sys.kill(pid, "SIGTERM")
  local waited = 0
  while running() and waited < STOP_SECONDS do
    sys.sleep(STOP_POLL)
    waited = waited + STOP_POLL
  end
  if running() then
    sys.kill(pid, "SIGKILL")
  end
  sys.unlink(PIDFILE)
  return 0
end

-- rc visitors restart.
function restart()
  stop()
  return start()
end

-- rc visitors status: says whether it runs; 0 when it does, 3 when not.
function status()
  local pid = running()
  print(name .. (pid and " is running (pid " .. pid .. ")" or " is stopped"))
  return pid and 0 or NOT_RUNNING
end

-- rc visitors count: an action of its own: how many visitors its log has.
function count()
  local seen = 0
  local file = io.open(LOG)
  if file then
    for line in file:lines() do
      if not line:find(" stopped$") then
        seen = seen + 1
      end
    end
    file:close()
  end
  print(seen .. " visitors")
  return 0
end

-- ticker: a service that wakes every few seconds, forever, and writes the world's time to
-- /home/ticker.log; when rc stops it (SIGTERM), it finishes the line it's on, says so, and ends.
-- Its argument is how many seconds it sleeps between lines (5 when not given).
local sys = require("sys")

local LOG = "/home/ticker.log"
local DEFAULT_SECONDS = 5 -- how long it sleeps between lines, unless its argument says

local seconds = tonumber(arg[1]) or DEFAULT_SECONDS

-- Appends a line to the log. Opened and closed each time: a file on a disk shows what's written
-- only once it's closed, so you can read the log while it runs.
local function log(text)
  local file = assert(io.open(LOG, "a"))
  file:write(os.date("%c"), " ", text, "\n")
  file:close()
end

-- rc's stop sends SIGTERM. The handler only notes it; the loop sees the note and ends. A sleep
-- the signal came in during returns early (EINTR), so it ends at once, not a sleep later.
local stopping = false
sys.signal("SIGTERM", function()
  stopping = true
end)

log("started, a line every " .. seconds .. " seconds")
local beats = 0
while not stopping do -- forever, until stopped
  beats = beats + 1
  log("tick " .. beats)
  sys.sleep(seconds) -- waits without using the CPU: the computer draws its waiting power
end
log("stopped after " .. beats .. " ticks")

-- /etc/rc.d/ticker: the ticker service, a line every 2 seconds, its output and errors in /tmp.
description = "writes the time to /home/ticker.log"
command = "/bin/lua"
command_args = {"/home/ticker.lua", "2"}
output_log = "/tmp/ticker.out"