[ Part 1 (Overview) – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 7 ]

Welcome to my blog’s first tutorial series!

How you doing today?

I hope you’re well because this video is about to bang you on the head!

Not in a bad way of course, we’re about to learn a lot of cool stuff; but, I must warn you, grab your drink in advance and strap in that chair. 🙂

In this episode, as promised, we’re going to merge both the server and client script into one and add a bunch of functionality as well.

Analysis Before Coding

Since there’s a lot of ground to cover, let’s take a deep breath first and think about some components before diving into the code.

In the last part, we concluded the server thread and I mentioned we would work on the client thread this time. Which we will. However, before that we must port over some functions from the client script into the server script.

For example, the connect back functionality from the client script will be ported over and improved upon to allow the user to either start a new connection or be used programmatically in the main server.

Only then we’ll be able to consider firing up those client threads…

Now about the main server: we’ll have to place it inside its own function. The main reason is so we can run it in the background as a thread. This will allow us to shut it down once we finish establishing a connection and quickly fire it up again to listen for the next client.

Finally we’ll implement the text-based user interface since all of our main components are now running in the background as daemons: the server threads, the client threads and the main server.

I think that’s enough context for now so let’s jump into some code!

[ Part 1 (Overview) – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 7 ]

Welcome to my blog’s first tutorial series!

Ayyyyoooo guys! What’s good?

Continuing from my last post, its time to implement the server thread.

A lot of pieces are already in place to handle the server threads, so we should be able to get it done without too much hassle.

There are some minor code changes in the server script which I will only be covering in the video above, so if you’re only following the blog make sure to download the code at the end of the post and compare the changes.

Let’s write some codes!

Server Handler Code

# Server handler
# --------------------------------------------
# This function will listen for connections as daemons
# and keep connected in background.
def ServerHandler(serverIP, serverPort, clientIP):
	sh = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	sh.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
	sh.bind((serverIP, serverPort))
	sh.listen(1)	# Listen for 1 client, each server = 1 client
	
z,b = sh.accept()
	if (z):
		print "\n[" + GetTime() + "] Connection from " + str(b)
		while True:
			msg = Receive(z)
			if len(str(msg)): print "\n[" + GetTime() + "] " + msg

There isn’t much to the server handler. Basically we fire up a socket using the supplied arguments serverIP and serverPort – this port is the one supplied by the AllocAddress() function we created in the previous part (will basically add +1 to the same port of the main server).

[ Part 1 (Overview) – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 7 ]

Welcome to my blog’s first tutorial series!

What’s going on guys? Are ready to keep on coding?

In this part we won’t write too much code, mostly we’re going to focus on the building blocks to setup our server thread in the future.

This includes setting up a few variables, some new functions and some overall analysis into how the server thread is going to work.

I already explained in the overview how the program is going to operate in regards to handling clients but now we’re actually going under the hood.

Without further ado, let’s code!

Dive Into The Code

On the server script, we’re going to add two new functions:

• CheckAddr(port, verbose)
• AllocAddress()

The purpose of these functions will become clear later on, but for the time being we are going to use them to check if the IP address we chose as a host is available; while the second function will work to find an available port for the client to connect back to us (in the client thread, which will be developed later on).

[ Part 1 (Overview) – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 7 ]

Welcome to my blog’s first tutorial series!

In the first part of this project, the overview, we looked at the finished program, how it’s going to look once we wrap up the last part along with a lot of details about everything we’ll be covering along the way.

If you haven’t checked out the first part, go ahead right now, I’ll wait…

Also make sure you have all the required software: Python 2.7.

Done? Alright, grab your beverage of choice and get ready!

Setting Up Our Script

From this point forward, all the information is in the video guide, assuming you have already installed a text editor (like Sublime Text or Notepad++)…

Let’s begin by creating a nice folder to save our script. I decided to name mine PyCS.py (as in Python Chat Server, abbreviated accordingly).

Since we’re going to develop two scripts separately at first, I recommend having that folder so you don’t make things messy in your desktop.

It’s also useful in case you need to backup one of the scripts along the way.

Let’s Write Some Code

I will not go fully in depth on each line of code here in the blog, since I made a 30 minute video where everything is explained clearly.

In any case, I will lay down explanations for individual blocks of code here.

Also if you don’t care about writing the code yourself, I will leave the script for download at the bottom of each post for easy access. 😉

[ Part 1 (Overview) – Part 2 – Part 3 – Part 4 – Part 5 – Part 6 – Part 7 ]

Welcome to my blog’s first tutorial series!

In this project we will program a Python chat server using threads to make sure we can receive any number of connections while still being able to handle many clients as well – using a single script as the final product for simplicity.

While searching the web, I was unable to find many tutorials that worked like this, so grab some coffee and get ready to start writing some code ayyy!

Fire up your favorite text editor!

Wait, hold up, not so fast there…

Before getting our hands dirty, let’s take a look at some details about this project, for example, what software we’ll need, what will you learn along the way, how exactly is this program going to operate, and so on.

Required Software

First of all, you will need Python 2.7 (as of right now, the current version is actually 2.7.17). Go ahead and install it from their official page. Note that older versions should work also, but you will be responsible for minor syntax changes.

Second thing you’ll need, of course, is a solid text editor. I highly recommend Sublime Text for many reasons which I could devote a whole post to (and I just might in the future!). In any case, Notepad++ is a solid choice too.

Alright, that’s all the software we need. On to the project…

What you will learn

The main goal of this project is to teach different components, such as:

• Using timestamps
• User input and output
• Text-based user interface (TUI)
• Handling multiple threads for client/server
• Understanding socket connections in networking
• Keeping track of logs for the system and conversations
• …among others that I’m lazy to think of right this moment 😉