3

查看这篇文章的底部，了解最终的工作代码。

这是一个工作 Python/CGI 脚本，它可以通过调用另一个脚本来获取 CGI 脚本的用户输入，然后通过本地套接字发送它的命令。

原帖：

据我所知，没有任何方法可以将用户输入直接发送到已经发送了标头的 Python/CGI 脚本。比如，在特定情况下警告用户并等待确认。我也找不到任何已发布的解决方案。

如果我错了，请纠正我。

我目前有一个 Python 脚本，它可以连接到服务器、上传固件、重启、重新连接、更改一些配置文件等。

有时，它可以帮助很多用户将输入发送到脚本，而不必重新启动脚本并从头开始执行它。通过 2G 网络重新连接需要很长时间。

我认为必须可以将用户输入发送到另一个脚本，然后将其发布到第一个/主脚本正在监视的文件中，直到它收到输入。如果能够使用停止/终止输入命令停止脚本的执行，那也很好。至于 stop/kill 命令，主脚本需要有 2 个线程。如果没有，它会知道它应该停止脚本，如果正在执行诸如大文件上传之类的过程，则在上传完成之前。

同时，我认为多个用户应该能够同时使用脚本。因此，每次启动主脚本时都必须生成一个唯一的 ID。

以下是我认为可以制作的方法：

主脚本被调用

Global variable with a unique session ID is generated and sent to client.

Thread 1
    pexpect spawns a "tail -F /var/www/cgi/tmp_cmd.log"

Thread 2
    Thread status "Busy"
    Connects to network element
    Does its usual stuff until it reaches a point where the user needs to interact.
    Prints the message to user and waits for Thread 1 with a timeout of x seconds.
    Thread status "Ready"

用户通过带有 2 个标头（会话 ID 和输入）的 AJAX 调用第二个脚本

第二个脚本

Session ID and user input is saved to "/var/www/cgi/tmp_cmd.log"
Execution of the input script ends

主脚本

Thread 1 
    User input recieved.
    Wait for Thread 2 status to become "Ready" or ignore status if command is equals to "kill" ect.
    Send user input (single line) and start Thread 1 from the beginning
Thread 2 
    Thread 2 status "Busy"
    Input recieved and process stops/continues.
    Thread 2 status "Ready"

我已经为连接、上传文件和运行命令制作了一个脚本。但是，它无法接收用户输入。

我真的可以使用一些很好的帮助，或者有人告诉我如何解决这个问题。

当然，每当脚本完成后，我都会将其发布在此处或粘贴到 pastebin 并链接到它，以供其他人使用。:)

最终代码

在下面帖子的帮助下，我终于有了工作代码。它可以使用线程，但停止/取消进程对我来说似乎更容易弄清楚。

客户端- cgi_send.py

#!/usr/bin/python
import sys, cgi, cgitb, socket

cgitb.enable()
TASKS_DIR = "/var/www/cgi-bin/tmp"

def main():
    global TASKS_DIR

    url = cgi.FieldStorage()
    cmd = str(url.getvalue('cmd'))
    sessionId = str(url.getvalue('session'))
    socketLocation = TASKS_DIR + '/%s.socket' % sessionId

    print '<a href="?session='+sessionId+'&cmd=QUIT">End script</a>&nbsp;<a href="?session='+sessionId+'&cmd=CANCEL">Cancel task</a>'
    print '<form action=""><input type="hidden" name="session" id="session" value="'+sessionId+'" /><input type="text" name="cmd" id="cmd" value="" /><input type="submit" value="Fun!" />'

    try:

        sock = socket.socket(socket.AF_UNIX)
        sock.setblocking(0)
        sock.connect(socketLocation)
        sock.send(cmd)
        sock.close()
        print '<br />Command sent: '+ cmd;

    except IOError:
        print '<br /><b>Operation failed.</b><br /> Could not write to socket: '+ socketLocation
        pass

    sock.close()

    sys.exit();

if __name__ == '__main__':
    sys.stdout.write("Content-type:text/html;charset=utf-8\r\n\r\n")
    sys.stdout.write('<!DOCTYPE html>\n<html><head><title>Test</title></head><body>')

    main()

    print '</body></html>'
    sys.exit()

服务器

#!/usr/bin/python
import sys, os, socket, uuid, time, multiprocessing

# Options
TASKS_DIR = "/var/www/cgi-bin/tmp/"

def main():

    sessionId = str(uuid.uuid4())

    print 'Session ID: '+ sessionId
    sys.stdout.write ('<br /><a href="cgi_send.py?cmd=test&session=' + sessionId +'" target="cmd_window">Send test command</a>')
    sys.stdout.flush()

    address = os.path.join(TASKS_DIR, '%s.socket' % sessionId)

    sock = socket.socket(socket.AF_UNIX)
    sock.setblocking(0)
    sock.settimeout(.1)
    sock.bind(address)
    sock.listen(1)

    taskList = [foo_task, foo_task, foo_task]

    try:
        for task in taskList:

            print "<br />Starting new task"
            runningTask = multiprocessing.Process(target=task)
            runningTask.daemon = True # Needed to make KeyboardInterrupt possible when testing in shell
            runningTask.start()

            while runningTask.is_alive():
                conn = None
                try:
                    conn, addr = sock.accept()
                    data = conn.recv(100).strip()

                except socket.timeout:
                    # nothing ready from a client
                    continue

                except socket.error, e:
                    print "<br />Connection Error from client"

                else:
                    print "<br />"+ data
                    sys.stdout.flush()
                    conn.close()

                    if data == "CANCEL":
                        # temp way to cancel our task
                        print "<br />Cancelling current task."
                        runningTask.terminate()

                    elif data == "QUIT":
                        print "<br />Quitting entire process." 
                        runningTask.terminate()
                        taskList[:] = []

                finally:
                    if conn:
                        conn.close()

    except (KeyboardInterrupt, SystemExit):
        print '\nReceived keyboard interrupt, quitting threads.'

    finally:
        sock.close()
        os.remove(address)

def foo_task():
    i = 1
    while 10 >= i:
        print "<br />Wating for work... "+ str(i)
        sys.stdout.flush()
        i = i + 1
        time.sleep(1)


if __name__ == '__main__':
    sys.stdout.write("Content-type:text/html;charset=utf-8\r\n\r\n")
    sys.stdout.write('<!DOCTYPE html>\n<html><head><title>Test</title></head><body>')

    main()

    print '</body></html>'
    sys.exit()
4

1 回答 1

2

CGI 脚本是一种非常原始的操作。它的工作原理与您从命令 shell 运行的任何普通脚本基本相同。向 Web 服务器发出 http 请求。服务器启动一个新进程并通过标准输入将参数传递给脚本。在这一点上，它就像一个普通的脚本。

除非脚本通过某种方式寻找输入，否则脚本无法获得更多输入，因此假设一旦发送标头，Web 客户端就不能再直接发送更多输入是正确的，因为请求已经在进行中，并且响应也已经在进行中。

监视文件的线程是将控制循环引入脚本的一种方法。另一种方法是根据每个实例的唯一 ID打开一个指向路径的 UNIX套接字。然后让线程坐在套接字上进行输入。然后您要做的就是将 ID 传递回 Web 客户端。并且客户端可以使用 ID 调用第二个脚本，然后它会知道正确的 UNIX 套接字路径以将控制命令发送到：即。

/tmp/script-foo/control/<id>.socket

您实际上可能只需要 1 个线程。您的主线程可以简单地循环检查有关套接字的信息，并监视正在线程或子进程中运行的当前操作。在伪代码中可能是这样的：

uid = generate_unique_id()
sock = socket.socket(AF_UNIX)
sock.bind('/tmp/script-foo/control/%s.socket' % uid)
# and set other sock options like timeout

taskList = [a,b,c]
for task in taskList:
    runningTask = start task in thread/process
    while runningTask is running:
        if new data on socket, with timeout N ms
            if command == restart:
                kill runningTask
                taskList = [a,b,c]
                break
            else:
                process command

当 Web 客户端通过 ajax 向您的第二个脚本发送命令时，它在伪代码中可能如下所示：

jobid = request.get('id')
cmd = request.get('cmd')
sock = socket.socket(socket.AF_UNIX)
sock.connect('/tmp/script-foo/control/%s.socket' % jobid)
sock.sendall(cmd)
sock.close()

更新

根据您的代码更新，这是我建议的一个工作示例：

import sys
import os
import socket
import uuid 
import time 

# Options
TASKS_DIR = "."

def main():

    sessionId = str(uuid.uuid4())

    print 'Session ID: '+ sessionId
    sys.stdout.write ('<br /><a href="cgi_send.py?cmd=test&session=' + sessionId +'" target="_blank">Send test command</a>')
    sys.stdout.flush()

    address = os.path.join(TASKS_DIR, '%s.socket' % sessionId)

    sock = socket.socket(socket.AF_UNIX)
    sock.setblocking(0)
    sock.settimeout(.1)
    sock.bind(address)
    sock.listen(1)


    fakeTasks = [foo_task, foo_task, foo_task]

    try:
        for task in fakeTasks:

            # pretend we started a task
            runningTask = task()
            # runningTask = Thread(target=task) 
            # runningTask.start()

            # while runningTask.is_alive():   
            while runningTask:
                conn = None
                try:
                    conn, addr = sock.accept()
                    data = conn.recv(100).strip()

                except socket.timeout:
                    # nothing ready from a client
                    continue

                except socket.error, e:
                    print "<br />Connection Error from client"

                else:
                    print "<br />"+ data
                    sys.stdout.flush()
                    conn.close()

                    # for the thread version, you will need some 
                    # approach to kill or interrupt it. 
                    # This is just simulating. 
                    if data == "CANCEL":
                        # temp way to cancel our task
                        print "<br />Cancelling current task." 
                        runningTask = False

                    elif data == "QUIT":
                        print "<br />Quitting entire process." 
                        runningTask = False 
                        fakeTasks[:] = []

                finally:
                    if conn:
                        conn.close()

    finally:
        sock.close()
        os.remove(address)



def foo_task():
    print 'foo task'
    return True


if __name__ == '__main__':
    sys.stdout.write("Content-type:text/html;charset=utf-8\r\n\r\n")
    sys.stdout.write('<!DOCTYPE html>\n<html><head><title>Test</title></head><body>')

    main()

    print '</body></html>'
    sys.exit()

您没有使用 10 秒的全局超时，而是将其设置为像 100 毫秒这样的小值。它遍历每个任务并启动它（最终在一个线程中），然后尝试循环等待套接字连接。如果 100ms 内没有连接，则超时并继续循环，同时检查任务是否完成。在任何时候，客户端都可以连接并发出“CANCEL”或“QUIT”命令。套接字将接受连接，读取它并做出反应。

您可以在此处查看解决方案如何不需要多个线程。您需要的唯一线程或子进程是运行任务。

于 2012-08-10T01:32:15.193 回答