在连续运行的python脚本中保持端口打开

Question

I'm trying to develop a server script using python 3.4 that runs perpetually and responds to client requests on up to 5 separate ports. My preferred platform is Debian 8.0. The platform currently runs on a virtual machine in the cloud. My script works fine when I run it off the command line - I need to now (1) keep it running once I log off the server and (2) keep several ports open through the script so that a windows client can connect to them.

For (1),

After trying several options [I tried using upstart, added the script to rc.local, used nohup with & to run it off the terminal, etc] that didn't seem to work, I eventually found something that does seem to keep the script running, even if it's not very elegant - I wrote an hourly cron script that checks to see if the script is running in the process list, and if not, to execute it.

Whenever I login to the VM now, I see the following output when I type 'ps -ef':

root 22007 21992 98 Nov10 14-12:52:59 /usr/bin/python3.4 /home/userxyz/cronserver.py

I assume that the script is running based on the fact that there is an active process in the system. I mention this part because I suspect that there could be a correlation with part (2) of my issue.

For (2),

The script is supposed to open ports 49100 - 49105 and listen for connection requests, etc. When I run the script from the terminal, zenmap from my client machine verifies that these ports are open. However, when the cron job initiates the script, these ports don't seem to stay open. My windows client program can't connect to the script either.

The python code I use for listening to a port:

    f = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    f.bind((serviceIP, 49101))
    f.listen(5)
    while True:
            scName, address = f.accept()

            [code to handle request]

            scName.shutdown(socket.SHUT_WR)
            scName.close()

Any insight or assistance would be greatly appreciated!

Answer 1

What you ask is not easy because it depends on a variety of factors:

• What is the frequency of the data received?
• How many clients are expected to connect to this server?
  • Is there a chance two clients try to connect at the same time?
• How long it takes to handle some received data?
• What do you need to do with your data?
  • Write to a database?
  • Write to a file?
  • Calculate something?
• Etc.

Depending on your answer you'll have some design decisions to make for your solution.

But since you need an answer, here's a hack that represent a way to do things:

import socketserver
import threading
import datetime

class SleepyGaryReceptionHandler(socketserver.BaseRequestHandler):

    log_file_name = "/tmp/sleepygaryserver.log"

    def handle(self):

        # self.request is defined in BaseRequestHandler
        data_received = self.request.recv(1024)
        # self.client_address is also defined in BaseRequestHandler
        sender_address = self.client_address[0]

        # This is where you are supposed to do something with your data
        # This is an example
        self.write_to_log('Someone from {} sent us "{}"'.format(sender_address,
                                                                data_received))

        # A way to stop the server from going on forever
        # But you could do this other ways but it depends what condition
        # should cause the shutdown
        if data_received.startswith(b"QUIT"):
            finishing_thread = threading.Thread(target=self.finish_in_another_thread)
            finishing_thread.start()

    # This will be called in another thread to terminate the server
    # self.server is also defined in BaseRequestHandler
    def finish_in_another_thread(self):
        self.write_to_log("Shutting down the server")
        self.server.shutdown()

    # Write something (with a timestamp) to a text file so that we
    # know something is happenning
    def write_to_log(self, message):
        timestamp = datetime.datetime.now()
        timestamp_text = timestamp.isoformat(sep=' ', timespec='seconds')
        with open(self.log_file_name, mode='a') as log_file:
            log_file.write("{}: {}\n".format(timestamp_text, message))

service_address = "localhost"
port_number = 49101

server = socketserver.TCPServer((service_address, port_number),
                                SleepyGaryReceptionHandler)
server.serve_forever()

I'm using here the socketserver module instead of listening directly at a socket. This standard library module has been written to simplify writing a server. so use it!

All I do here is write to a text file what has been received. You would have to adapt it to your use.

But to have it running continuously use a cron job but to start it at the startup of the computer. Since this script will block until the server is stopped, we have to run it in the background. It would look something like that:

 @reboot /usr/bin/python3 /home/sleepygary/sleppys_server.py &

I have tested it and after 5 hours it still does his thing.

Now like I said, it is a hack. If you want to go all the way and do things like any other services on your computer you have to program it in a certain way. You can find more information on this page: https://www.freedesktop.org/software/systemd/man/daemon.html

I'm really tired so there may be some errors here and there.