Question

查看此帖子的底部，了解最终的工作代码。

这是一个有效的Python / CGI脚本，通过调用另一个脚本然后通过本地套接字发送它的命令，可以将用户输入到CGI脚本。

原帖：

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

如果我错了，请纠正我。

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

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

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

与此同时，我认为multipe用户应该能够同时使用该脚本。因此，每次启动主脚本时都必须生成唯一的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上发布并链接到它，供其他人使用。：）

最终代码

在下面的帖子的帮助下，我终于有了工作代码。它可以使用Threads，但停止/取消过程似乎更容易让我弄明白。

客户 - 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()

Answer 1

CGI脚本是一种非常原始的操作。它的工作原理与从命令shell运行的任何普通脚本基本相同。向Web服务器发出http请求。服务器启动一个新进程并将via stdin中的参数传递给脚本。此时，它就像一个普通的脚本。

除非通过某种方式查找输入，否则脚本无法获得任何输入，因此您可以正确地假设一旦发送标题，Web客户端就不能再直接发送更多输入，因为请求已经是正在进行中，反应也在进行中。

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

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

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

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

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

Python - 通过CGI的用户输入。线程和阅读文件

1 个答案: