evennia/src/session.py

"""
This module contains classes related to Sessions. session_mgr has the things
needed to manage them.
"""
import time
import sys
from datetime import datetime
from twisted.conch.telnet import StatefulTelnetProtocol
from django.contrib.auth.models import User
from django.conf import settings
from util import functions_general
from src.objects.models import Object
from src.channels.models import CommChannel, CommChannelMembership
from src.config.models import ConnectScreen, ConfigValue
from src import comsys
import cmdhandler
import logger
import session_mgr
import ansi

class SessionProtocol(StatefulTelnetProtocol):
    """
    This class represents a player's sesssion. From here we branch down into
    other various classes, please try to keep this one tidy!
    """

    def connectionMade(self):
        """
        What to do when we get a connection.
        """
        self.prep_session()
        logger.log_infomsg('New connection: %s' % self)
        self.cemit_info('New connection: %s' % self)
        session_mgr.add_session(self)
        self.game_connect_screen()

    def getClientAddress(self):
        """
        Returns the client's address and port in a tuple. For example
        ('127.0.0.1', 41917)
        """
        return self.transport.client

    def prep_session(self):
        self.server = self.factory.server
        self.address = self.getClientAddress()
        self.name = None
        self.uid = None
        self.pobject = None
        self.logged_in = False
        # The time the user last issued a command.
        self.cmd_last = time.time()
        # Player-visible idle time, excluding the IDLE command.
        self.cmd_last_visible = time.time()
        # Total number of commands issued.
        self.cmd_total = 0
        # The time when the user connected.
        self.conn_time = time.time()
        self.channels_subscribed = {}

    def disconnectClient(self):
        """
        Manually disconnect the client.
        """
        self.transport.loseConnection()

    def connectionLost(self, reason):
        """
        Execute this when a client abruplty loses their connection.
        """
        logger.log_infomsg('Disconnected: %s' % self)
        self.cemit_info('Disconnected: %s.' % self)
        self.handle_close()
        
    def lineReceived(self, data):
        """
        Any line return indicates a command for the purpose of a MUD. So we take
        the user input and pass it to this session's pobject.
        """
        if self.pobject:
            # Session is logged in, run through the normal object execution.
            self.pobject.execute_cmd(data, session=self)
        else:
            # Not logged in, manually execute the command.
            cmdhandler.handle(cmdhandler.Command(None, data, session=self))

    def execute_cmd(self, command_str):
        """
        Sends a command to this session's object for processing.
        """
        self.pobject.execute_cmd(command_str, session=self)
      
    def count_command(self, silently=False):
        """
        Hit this when the user enters a command in order to update idle timers
        and command counters. If silently is True, the public-facing idle time
        is not updated.
        """
        # Store the timestamp of the user's last command.
        self.cmd_last = time.time()
        if not silently:
            # Increment the user's command counter.
            self.cmd_total += 1
            # Player-visible idle time, not used in idle timeout calcs.
            self.cmd_last_visible = time.time()
            
    def handle_close(self):
        """
        Break the connection and do some accounting.
        """
        pobject = self.get_pobject()
        if pobject:
            pobject.set_flag("CONNECTED", False)
            
            location = pobject.get_location()
            if location != None:
                location.emit_to_contents("%s has disconnected." % (pobject.get_name(show_dbref=False),), exclude=pobject)

            uaccount = pobject.get_user_account()
            uaccount.last_login = datetime.now()
            uaccount.save()
            
        self.disconnectClient()
        self.logged_in = False
        session_mgr.remove_session(self)
        
    def get_pobject(self):
        """
        Returns the object associated with a session.
        """
        # If the pobject is already cached, return it and skip the lookup.
        if self.pobject:
            return self.pobject
        
        try:
            # Cache the result in the session object for quick retrieval.
            result = Object.objects.get(id=self.uid)
            self.pobject = result
            return result
        except:
            logger.log_errmsg("No pobject match for session uid: %s" % self.uid)
            return None
        
    def game_connect_screen(self):
        """
        Show the banner screen. Grab from the 'connect_screen' config directive.
        """
        screen = ConnectScreen.objects.get_random_connect_screen()
        buffer = ansi.parse_ansi(screen.text)
        self.msg(buffer)

    def is_loggedin(self):
        """
        Returns a boolean True if the session is logged in.
        """
        try:
            return self.logged_in
        except:
            return False
    
    def login(self, user):
        """
        After the user has authenticated, handle logging him in.
        """
        self.uid = user.id
        self.name = user.username
        self.logged_in = True
        self.conn_time = time.time()
        # This will cache with the first call of this function.
        self.get_pobject()
        #session_mgr.disconnect_duplicate_session(self)
        
        self.pobject.scriptlink.at_pre_login(self)
        self.pobject.scriptlink.at_post_login(self)
        
        logger.log_infomsg("Logged in: %s" % self)
        self.cemit_info('Logged in: %s' % self)
        
        # Update their account's last login time.
        user.last_login = datetime.now()        
        user.save()
        
        # In case the account and the object get out of sync, fix it.
        if self.pobject.name != user.username:
            self.pobject.set_name(user.username)
            self.pobject.save()
        
    def msg(self, message):
        """
        Sends a message to the session.
        """
        if isinstance(message, unicode):
             message = message.encode("utf-8")
        self.sendLine("%s" % (message,))
        
    def add_default_channels(self):
        """
        Adds the player to the default channels.
        """        
        # Add the default channels.
        for chan in CommChannel.objects.filter(is_joined_by_default=True):
            logger.log_infomsg("ADDING BY DEFAULT %s" % chan)
            chan_alias = chan.get_default_chan_alias()
            membership = CommChannelMembership(channel=chan, 
                                               listener=self.get_pobject(),
                                               user_alias=chan_alias)
            membership.save()
            
            comsys.plr_set_channel_listening(self, chan_alias, True)
        
    def __str__(self):
        """
        String representation of the user session class. We use
        this a lot in the server logs and stuff.
        """
        if self.is_loggedin():
            symbol = '#'
        else:
            symbol = '?'
        return "<%s> %s@%s" % (symbol, self.name, self.address,)
    
    def cemit_info(self, message):
        """
        Channel emits info to the appropriate info channel. By default, this
        is MUDConnections.
        """
        comsys.send_cmessage(settings.COMMCHAN_MUD_CONNECTIONS, 
                             'Session: %s' % message)