PythonChatServer.py

#!/usr/bin/python
# Run with cd C:\Users\Joshua Bowe\Downloads\python code downloaded\Chapter 16
#Then do py PythonChatServer.py 127.0.0.1 20000
# or py -3 PythonChatServer.py 127.0.0.1 8000
import socketserver
import re
import socket
import socketserver as SocketServer
import os
#####STARTING LOG FILE#########
import time##import time, so you can create the log file for the day
foo=time.asctime().split(' ')
l=[foo[4], foo[1], foo[2]]
def make_log_name(l):
 """you take in a list. It contains the year, month, and day in that order. It
returns a nicely formatted name"""
 f="%s_%s-%s"%(l[0],l[1],l[2])
 f=f.replace(':',';')
 print(f)
 return f
filen=os.path.join('logs',make_log_name(l))
bar=open(filen,'a')
bar.write("Started server at \"%s\"\n"%time.asctime())
bar.close()
print("Wrote to log file %s"%filen)
def write_text(text):
 bar=open(filen,'a')
 bar.write(text)
 bar.close()
 del bar
def write_p(text,p=0):
 if p==1:print(text)
 write_text(text)
del foo,l,make_log_name,bar

#############END LOG FILE SECTION
def b(string):return string.encode()
def d(Bytes):return Bytes.decode()
def join(S,it):
 foo=""
 it=list(it)
 for i in range(len(it)-1):
 foo+="%s%s"%(d(it[i]),S)
 foo+='%s'%d(it[-1])
 return foo
##users={'joshb':'Woof!!!','bowej':'!!!fooW'}##Testing
##print(join(', ',users.keys()))##Testing
class ClientError(Exception):
 "An exception thrown because the client gave bad input to the server."
 pass

class PythonChatServer(socketserver.ThreadingTCPServer):
 "The server class."

 def __init__(self, server_address, RequestHandlerClass):
 """Set up an initially empty mapping between a user's nickname
 and the file-like object used to send data to that user."""
 SocketServer.ThreadingTCPServer.__init__(self, server_address,
 RequestHandlerClass)
 self.users = {}

class RequestHandler(SocketServer.StreamRequestHandler):
 """Handles the life cycle of a user's connection to the chat
 server: connecting, chatting, running server commands, and
 disconnecting."""

 NICKNAME = re.compile('^[A-Za-z0-9_-]+$') #Regex for a valid nickname

 def handle(self):
 """Handles a connection: gets the user's nickname, then
 processes input from the user until they quit or drop the
 connection."""
 self.nickname = None

 self.privateMessage('Who are you?')
 nickname = self._readline()
 done = False
 try:
 self.nickCommand(nickname)
 self.privateMessage('Hello %s, welcome to the Python Chat Server.'\
 % d(nickname))
 self.broadcast('%s has joined the chat.' % d(nickname), False)
 except ClientError as error:
 self.privateMessage(error.args[0]) 
 done = True
 except socket.error:
 done = True
## print("\"%s\" has logged in."%d(self.nickname))
 write_p("\"%s\" has logged in.\n"%d(self.nickname),1)
 #Now they're logged in; let them chat.
 while not done:
 try:
 done = self.processInput()
 except ClientError as error:
 self.privateMessage(str(error))
 except socket.error as e:
 done = True

 def finish(self): 
 "Automatically called when handle() is done."
 if self.nickname:
 #The user successfully connected before disconnecting. 
 #Broadcast that they're quitting to everyone else.
 message = '%s has quit.' % d(self.nickname)
 if hasattr(self, 'partingWords'):
 message = '%s has quit: %s' % (d(self.nickname),
 self.partingWords)
 self.broadcast(message, False)

 #Remove the user from the list so we don't keep trying to
 #send them messages.
 if self.server.users.get(self.nickname):
 write_p("\"%s\" has quit.\n"%d(self.nickname),1)
 del(self.server.users[self.nickname])
 self.request.shutdown(2)
 self.request.close()

 def processInput(self):
 """Reads a line from the socket input and either runs it as a
 command, or broadcasts it as chat text."""
 done = False
 l = self._readline()
 command, arg = self._parseCommand(l)
 if command:
 done = command(arg)
 else:
 l = '<%s> %s\n' % (d(self.nickname), d(l))
 write_p("To all: %s"%l)
 self.broadcast(l)
 return done
 #Each server command is implemented as a method. The _parseCommand method, defined later, takes a line that looks like /nick and calls the corresponding method (in this case, nickCommand):
 #Below are implementations of the server commands.

 def nickCommand(self, nickname):
 """Attempts to change a user's nickname.

The new(and not working code is below
if not nickname:
 raise ClientError ('No nickname provided.')
## print(self.NICKNAME,type(self.NICKNAME),'\n',
## nickname,type(nickname))#Testing
 if type(nickname)==str:nickname.encode()
 if type(nickname)==bytes:
 if not self.NICKNAME.match(d(nickname)):
 raise ClientError ('Invalid nickname: %s' % nickname)
 elif type(nickname)==str:
 if not self.NICKNAME.match(nickname):
 raise ClientError ('Invalid nickname: %s' % nickname)
 if nickname == self.nickname:
 raise ClientError ('You are already known as %s.' % nickname)
 if self.server.users.get(nickname, None):
 raise ClientError ('There\'s already a user named "%s" here.' % nickname)
 oldNickname = None
 if self.nickname:
 oldNickname = self.nickname
 del(self.server.users[self.nickname])
 self.server.users[nickname] = self.wfile
 self.nickname = nickname
 if oldNickname:"""
 if not nickname:
 raise ClientError ('No nickname provided.')
 if type(nickname)==str:
 nickname=b(nickname)
 if not self.NICKNAME.match(d(nickname)):
 raise ClientError ('Invalid nickname: %s' % nickname)
 if nickname == self.nickname:
 raise ClientError ('You are already known as %s.' % nickname)
 if self.server.users.get(nickname, None):
 raise ClientError ('There\'s already a user named "%s" here.' % nickname)
 oldNickname = None
 if self.nickname:
 oldNickname = self.nickname
 del(self.server.users[self.nickname])
 self.server.users[nickname] = self.wfile
 self.nickname = nickname
 if oldNickname:
 self.broadcast('%s is now known as %s' % (d(oldNickname),
 d(self.nickname)))
 def quitCommand(self, partingWords):
 """Tells the other users that this user has quit, then makes
 sure the handler will close this connection."""
 if partingWords:
 self.partingWords = partingWords
 #Returning True makes sure the user will be disconnected.
 return True

 def namesCommand(self, ignored):
 "Returns a list of the users in this chat room."
 user_list=join(', ',self.server.users.keys())
 self.privateMessage(user_list)
 def msgCommand(self,nickAndMsg):
 "Send a private message to another user"
 if type(nickAndMsg)==None or type(nickAndMsg)==type(None):
 self.privateMessage("No input given")
 return
 if len(nickAndMsg)==0:
 self.privateMessage("No input given")
 return
 if not ' ' in nickAndMsg:
 self.privateMessage("No message given, use a space ' ' to give one")
 return
 nick,msg=nickAndMsg.split(' ',1)
 if nick==self.nickname:
 self.privateMessage("What, send a message to yourself?")
 return
 user = self.server.users.get(b(nick))
## print(user,nick,self.server,self.server.users)
 if not user:
 self.privateMessage("No such user: '%s'"%nick)
 return
 msg="[Private from %s] %s\r\n"%(d(self.nickname),msg)
 write_p(msg)
## write_p("%s:%s"%(user,type(user)),1)
 user.write(b(msg))
 return
 # Below are helper methods.
 
 def broadcast(self, message, includeThisUser=True):
 """Send a message to every connected user, possibly exempting the
 user who's the cause of the message."""
 message = self._ensureNewline(message)
 for user, output in self.server.users.items():
 if includeThisUser or user != self.nickname:
 output.write(b(message))

 def privateMessage(self, message):
 "Send a private message to this user."
 n=self._ensureNewline(message).encode()
 self.wfile.write(n)

 def _readline(self):
 "Reads a line, removing any whitespace."
 return self.rfile.readline().strip()

 def _ensureNewline(self, s):
 "Makes sure a string ends in a newline."
 if s and s[-1] != '\n':
 s += '\r\n'
 return s

 def _parseCommand(self, i):
 """Try to parse a string as a command to the server. If it's an
 implemented command, run the corresponding method."""
 i=d(i)
 commandMethod, arg = None, None
 if i and i[0] == '/':
 if len(i) < 2:
 raise ClientError( 'Invalid command: "%s"' % i)
 commandAndArg = i[1:].split(' ', 1)
 if len(commandAndArg) == 2:
 command, arg = commandAndArg
 else:
 command, = commandAndArg
 commandMethod = getattr(self, command + 'Command', None)
 if not commandMethod:
 raise ClientError( 'No such command: "%s"' % command)
 return commandMethod, arg

if __name__ == '__main__':
 import sys
## sys.argv.append('127.0.0.1');sys.argv.append('27272')
 if len(sys.argv) < 3:
 print('Usage: %s [hostname] [port number]' % sys.argv[0])
 sys.exit(1)
 hostname = sys.argv[1]
 port = int(sys.argv[2])
 PythonChatServer((hostname, port), RequestHandler).serve_forever()