carbonmu 0.0.1

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  emits:
+    say: '%{name} says, "%{message}"'
+    pose: '%{name} %{message}'
+    semipose: '%{name}%{message}'
+    emit: '<%{name}> %{message}'

data/config/locales/nl.yml

@@ -0,0 +1,6 @@
+nl:
+  emits:
+    say: '%{name} zegt, "%{message}"'
+    pose: '%{name} %{message}'
+    semipose: '%{name}%{message}'
+    emit: '<%{name}> %{message}'

data/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# Console for testing. TODO replace me with a proper cli.
+
+require './lib/carbonmu.rb'
+require 'awesome_print'
+require 'pry'
+
+CarbonMU::Server.initialize_database
+Pry.start CarbonMU

data/lib/carbonmu.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'require_all'
+require 'colorize' # An exception to our require-where-used rule, since it's likely to be used many places.
+require_all 'lib'
+
+Celluloid::ZMQ.init
+
+module CarbonMU
+  class << self
+    attr_accessor :configuration
+    attr_accessor :edge_router_receive_port
+    attr_accessor :server
+  end
+  self.configuration = Configuration.new
+
+  def self.configure
+    yield self.configuration
+  end
+
+  def self.start
+    EdgeRouterSupervisionGroup.run
+  end
+
+  def self.start_in_background
+    EdgeRouterSupervisionGroup.run!
+  end
+
+  def self.start_server
+    ServerSupervisionGroup.run
+  end
+
+  def self.start_server_in_background
+    ServerSupervisionGroup.run!
+  end
+
+  def self.t(str, *opts)
+    CarbonMU::Internationalization.translate(str, opts)
+  end
+end
+

data/lib/commands/locale_command.rb

@@ -0,0 +1,12 @@
+# TODO TEMP
+module CarbonMU
+  class LocaleCommand < Command
+    syntax /^locale (?<locale>.*)/
+    syntax /^do (?<text>.*)/
+
+    def execute
+      @context.enacting_connection.locale = @params[:locale]
+      Notify.one(@context.enacting_connection, "Locale changed to #{@params[:locale]}.")
+    end
+  end
+end

data/lib/commands/ping_command.rb

@@ -0,0 +1,9 @@
+module CarbonMU
+  class PingCommand < Command
+    syntax "ping"
+
+    def execute
+      Notify.one(@context.enacting_connection, "PONG")
+    end
+  end
+end

data/lib/commands/reboot_command.rb

@@ -0,0 +1,9 @@
+module CarbonMU
+  class RebootCommand < Command
+    syntax "reboot"
+
+    def execute
+      Reboot.reboot
+    end
+  end
+end

data/lib/commands/say_command.rb

@@ -0,0 +1,10 @@
+module CarbonMU
+  class SayCommand < Command
+    syntax /^say (?<text>.*)/
+    syntax /^do (?<text>.*)/
+
+    def execute
+      Notify.all("emits.say", {name: @context.enactor.name, message: @params[:text].light_white})
+    end
+  end
+end

data/lib/commands/unknown_command.rb

@@ -0,0 +1,7 @@
+module CarbonMU
+  class UnknownCommand < Command
+    def execute
+      Notify.one(@context.enacting_connection, "Unknown command: #{@context.raw_command}")
+    end
+  end
+end

data/lib/core/command.rb

@@ -0,0 +1,26 @@
+module CarbonMU
+  class Command
+    class << self
+      def syntax(value)
+        @syntaxes ||= []
+        @syntaxes << value
+        Parser.register_syntax(value, self)
+      end
+
+      def syntaxes
+        @syntaxes
+      end
+    end
+
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+      @params = context.params
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+  end
+end

data/lib/core/command_context.rb

@@ -0,0 +1,12 @@
+module CarbonMU
+  class CommandContext
+    attr_reader :enacting_connection, :enactor, :raw_command, :params
+
+    def initialize(opts)
+      @enacting_connection = opts[:enacting_connection] || nil
+      @enactor = @enacting_connection.player || nil
+      @raw_command = opts[:raw_command] || ""
+      @params = opts[:params] || {}
+    end
+  end
+end

data/lib/core/configuration.rb

@@ -0,0 +1,22 @@
+require 'celluloid'
+require 'logger'
+
+module CarbonMU
+  class Configuration
+    attr_accessor :game_name
+    attr_reader :logger
+    attr_accessor :log_ipc_traffic
+
+    def initialize
+      @game_name = 'CarbonMU'
+      @logger = Celluloid.logger.tap { |i| i.progname = @game_name }
+      @log_ipc_traffic = true
+    end
+
+    def logger=(logger)
+      raise ArgumentError.new("Not a logger: #{logger}") unless logger.is_a?(Logger)
+      Celluloid.logger = logger
+      @logger = logger
+    end
+  end
+end

data/lib/core/connection.rb

@@ -0,0 +1,19 @@
+module CarbonMU
+  class Connection
+    attr_reader :id
+    attr_accessor :locale
+    attr_accessor :player
+
+    # TODO probably need edge type (:telnet, :ssl, etc), or at least interactive true/false
+    def initialize(id)
+      @id = id
+      @locale = "en" # TODO configurable default locale
+      @player = nil
+    end
+
+    def write_translated(msg, args = {})
+      translation_args = args.merge(locale: @locale)
+      CarbonMU.server.write_to_connection(id, I18n.t(msg, translation_args) + "\n")
+    end
+  end
+end

data/lib/core/internationalization.rb

@@ -0,0 +1,16 @@
+require "i18n"
+require "i18n/backend/fallbacks"
+
+module CarbonMU
+  module Internationalization
+
+    def self.setup
+      I18n.enforce_available_locales = false
+      I18n.load_path = Dir["config/locales/**/*.yml"] # TODO support for plugins too.
+    end
+
+    def self.translate(str, *opts)
+      I18n.t(str, opts)
+    end
+  end
+end

data/lib/core/parser.rb

@@ -0,0 +1,29 @@
+module CarbonMU
+  module Parser
+    def self.parse_and_execute(enacting_connection, input)
+      command_class, params = parse(input)
+
+      context = CommandContext.new(enacting_connection: enacting_connection, raw_command: input, params: params)
+      command_class.new(context).execute
+    end
+
+    def self.parse(input)
+      syntax_match_data = {}
+      syntax_and_class = @@syntaxes.detect { |syntax, klass| syntax_match_data = syntax.match(input) }
+
+      command_class = syntax_and_class.nil? ? UnknownCommand : syntax_and_class[1]
+      syntax_match_data ||= {} # if no syntaxes matched
+
+      [command_class, syntax_match_data.to_hash]
+    end
+
+    def self.register_syntax(syntax, klass)
+      @@syntaxes ||= {}
+      @@syntaxes[syntax] = klass
+    end
+
+    def self.syntaxes
+      @@syntaxes
+    end
+  end
+end

data/lib/core/server.rb

@@ -0,0 +1,118 @@
+require 'celluloid/io'
+require 'celluloid/zmq'
+require 'mongoid'
+
+module CarbonMU
+  class Server
+    include Celluloid::IO
+    include Celluloid::Logger
+    include Celluloid::ZMQ
+
+    finalizer :shutdown
+
+    attr_reader :connections
+
+    def initialize(standalone = false)
+      Internationalization.setup
+
+      info "*** Starting CarbonMU game server to connect to edge router port #{CarbonMU.edge_router_receive_port}."
+      CarbonMU.server = Actor.current
+
+      Server.initialize_database
+      Server.create_starter_objects
+
+      unless standalone
+        @ipc_reader = ReadSocket.new
+        @ipc_writer = WriteSocket.new(CarbonMU.edge_router_receive_port)
+        send_server_started_to_edge_router
+
+        async.run
+
+        retrieve_existing_connections
+      end
+    end
+
+    def run
+      loop do
+        async.handle_edge_router_message(@ipc_reader.read)
+      end
+    end
+
+    def shutdown
+      error "Terminating server!"
+    end
+
+    def add_connection(connection_id)
+      @connections ||= []
+      c = Connection.new(connection_id)
+      c.player = Player.superadmin #TODO real login
+      @connections << c
+    end
+
+    def remove_connection(connection_id)
+      @connections.delete_if { |c| c.id == connection_id }
+    end
+
+    def handle_command(input, connection_id)
+      connection = @connections.find { |c| c.id == connection_id }
+      Parser.parse_and_execute(connection, input)
+    end
+
+    def write_to_connection(connection_id, str)
+      send_message_to_edge_router(:write, connection_id: connection_id, output: str)
+    end
+
+    def send_server_started_to_edge_router
+      send_message_to_edge_router(:started, port: @ipc_reader.port_number, pid: Process.pid)
+    end
+
+    def handle_edge_router_message(input)
+      message = IPCMessage.unserialize(input)
+      debug "SERVER RECEIVE: #{message}" if CarbonMU.configuration.log_ipc_traffic
+      case message.op
+      when :command
+        handle_command(message.command, message.connection_id)
+      when :connect
+        add_connection(message.connection_id)
+      when :disconnect
+        remove_connection(message.connection_id)
+      else
+        raise ArgumentError, "Unsupported operation '#{message.op}' received from edge router."
+      end
+    end
+
+    def retrieve_existing_connections
+      send_message_to_edge_router(:retrieve_existing_connections)
+    end
+
+    def self.trigger_reboot
+      Actor[:server].send_reboot_message_to_edge_router
+    end
+
+    def send_reboot_message_to_edge_router
+      send_message_to_edge_router(:reboot)
+    end
+
+    def send_message_to_edge_router(op, params={})
+      message = IPCMessage.new(op, params)
+      debug "SERVER SEND: #{message}" if CarbonMU.configuration.log_ipc_traffic
+      @ipc_writer.send message.serialize
+    end
+
+    def self.initialize_database
+      Mongoid.logger.level = ::Logger::DEBUG
+      Mongoid.load!("mongoid.yml", ENV["MONGOID_ENV"] || :production)
+      ::Mongoid::Tasks::Database.create_indexes
+    end
+
+    def self.create_starter_objects
+      ensure_special_exists(:starting_room, Room, {name: "Starting Room", description: "This is the starting room for newly-created players. Feel free to rename and re-describe it."})
+      ensure_special_exists(:lostandfound_room, Room, {name: "Lost & Found Room", description: "This is the room where objects and players go if the thing that was holding them gets destroyed."})
+      ensure_special_exists(:superadmin_player, Player, {name: "Superadmin", description: "Obviously the most powerful of his race, it could kill us all."})
+    end
+
+    def self.ensure_special_exists(special, klass, attributes)
+      klass.create!(attributes.merge(_special: special)) if klass.where(_special: special).count == 0
+    end
+  end
+end

data/lib/core/server_supervision_group.rb

@@ -0,0 +1,5 @@
+module CarbonMU
+  class ServerSupervisionGroup < Celluloid::SupervisionGroup
+    supervise Server, as: :server
+  end
+end

data/lib/core_ext/match_data.rb

@@ -0,0 +1,7 @@
+class MatchData
+  def to_hash
+    ret = Hash.new
+    names.each { |k| ret[k.to_sym] = self[k] }
+    return ret
+  end
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def collectionize
+    split(":").last.tableize # Don't put module name in default Mongoid collection names.
+  end
+end

data/lib/edge_router/edge_connection.rb

@@ -0,0 +1,39 @@
+module CarbonMU
+  class EdgeConnection
+    include Celluloid::IO
+    include Celluloid::Logger
+
+    attr_accessor :name
+    attr_reader :id
+
+    finalizer :shutdown
+
+    def initialize(arg = nil)
+      @id = SecureRandom.uuid
+      after_initialize(arg)
+    end
+
+    def after_initialize(arg)
+      nil # to be implemented by subclasses, if desired
+    end
+
+    def handle_input(input)
+      input.chomp!
+      Actor[:edge_router].async.send_command_to_server(input, id)
+    end
+
+    def run
+      raise NotImplementedError
+    end
+
+    def shutdown
+      before_shutdown
+      Actor[:edge_router].async.remove_connection(Actor.current)
+    end
+
+    def before_shutdown
+      nil # to be implemented by subclasses, if desired
+    end
+  end
+end
+

data/lib/edge_router/edge_router.rb

@@ -0,0 +1,104 @@
+require 'celluloid/autostart'
+require 'celluloid/io'
+require 'celluloid/zmq'
+
+module CarbonMU
+  class EdgeRouter
+    include Celluloid::IO
+    include Celluloid::Logger
+    include Celluloid::ZMQ
+
+    finalizer :shutdown
+
+    attr_reader :receptors, :connections
+
+    def initialize(host, port)
+      info "*** Starting CarbonMU edge router."
+      @receptors = TelnetReceptor.new(host,port)
+      @connections = []
+
+      @ipc_reader = ReadSocket.new
+      info "*** Edge router waiting for IPC on port #{@ipc_reader.port_number}"
+      async.run
+
+      start_server
+    end
+
+    def start_server
+      spawn("/usr/bin/env ruby start-server-only #{@ipc_reader.port_number}")
+    end
+
+    def handle_server_started(pid, port)
+      debug "*** Edge router received server IPC start. Pid #{pid}, port #{port}." if CarbonMU.configuration.log_ipc_traffic
+      @current_server_pid = pid
+      Process.detach(pid)
+      @ipc_writer = WriteSocket.new(port)
+    end
+
+    def add_connection(connection)
+      @connections << connection
+      send_connect_to_server(connection)
+    end
+
+    def remove_connection(connection)
+      @connections.delete(connection)
+      send_disconnect_to_server(connection)
+    end
+
+    def shutdown
+      # TODO Tell all receptors and connections to quit.
+      Process.kill("TERM", @current_server_pid)
+    end
+
+    def run
+      loop do
+        async.handle_server_message(@ipc_reader.read)
+      end
+    end
+
+    def send_connect_to_server(connection)
+      send_message_to_server(:connect, connection_id: connection.id)
+    end
+
+    def send_disconnect_to_server(connection)
+      send_message_to_server(:disconnect, connection_id: connection.id)
+    end
+
+    def send_command_to_server(input, connection_id)
+      send_message_to_server(:command, command: input, connection_id: connection_id)
+    end
+
+    def send_message_to_server(op, params={})
+      message = IPCMessage.new(op, params)
+      debug "EDGE ROUTER SEND: #{message}" if CarbonMU.configuration.log_ipc_traffic
+      @ipc_writer.send message.serialize
+    end
+
+    def reboot_server
+      warn "Reboot triggered!"
+      Process.kill("TERM", @current_server_pid)
+      start_server
+    end
+
+    def handle_server_message(input)
+      message = IPCMessage.unserialize(input)
+      debug "EDGE ROUTER RECEIVE: #{message}" if CarbonMU.configuration.log_ipc_traffic
+      case message.op
+      when :started
+        handle_server_started(message.pid, message.port)
+      when :write
+        conn = @connections.select {|x| x.id == message.connection_id}.first # TODO look for efficiency here
+        conn.write(message.output)
+      when :reboot
+        reboot_server
+      when :retrieve_existing_connections
+        info 'Sending connections to server...'
+        @connections.each do |conn|
+          send_connect_to_server(conn)
+        end
+      else
+        raise ArgumentError, "Unsupported operation '#{message.op}' received from Server."
+      end
+    end
+  end
+end