如何让本地Python程序感知服务器文件变更（无需Socket及FTP轮询）

Hey there! Let's tackle this problem—you want to avoid constant FTP polling and don't have access to PHP sockets, so we need some clever workarounds to get your Python app notified when the XML changes on the server. Here are a few practical, low-fuss solutions you can try:

1. Webhook Trigger (Direct Server-to-Local Notification) #

If your local machine can be reached from the public internet (or you can use a tunnel tool), this is the most efficient option. The idea is: when someone edits the XML on your website, your site sends a quick HTTP request to your Python app, telling it to pull the updated file immediately.

How to set it up: #

• Step 1: Add a simple endpoint to your Python app using a lightweight framework like Flask:

from flask import Flask
import requests

app = Flask(__name__)
XML_FILE_URL = "https://your-website.com/path/to/your.xml"
LOCAL_XML_PATH = "./local-copy.xml"

@app.route("/sync-xml", methods=["POST"])
def sync_xml():
    # Fetch the updated XML from the server
    response = requests.get(XML_FILE_URL)
    response.raise_for_status()  # Handle any HTTP errors
    
    # Save to local
    with open(LOCAL_XML_PATH, "wb") as f:
        f.write(response.content)
    
    return "Synced successfully", 200

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)  # Listen on all network interfaces

• Step 2: On your website, after saving the edited XML, add code to send a POST request to your Python app's endpoint. For example, if your site uses PHP (even without sockets), you can use curl or file_get_contents:

// After saving the XML file
$webhook_url = "http://your-public-ip:5000/sync-xml"; // Or a tunnel URL (see below)
file_get_contents($webhook_url, false, stream_context_create([
    "http" => ["method" => "POST"]
]));

• If you don't have a public IP: Use a tool like ngrok to create a temporary tunnel to your local machine. Run ngrok http 5000 and use the generated URL (like https://abc123.ngrok.io/sync-xml) as your webhook target.

2. Hash Comparison (Low-Traffic Polling Alternative) #

If webhooks aren't feasible, you can drastically reduce polling overhead by only checking the file's hash (instead of downloading the entire XML every time). A hash is a small string that changes if the file content does—so you only download the full file when the hash differs.

Example Python code: #

import hashlib
import requests
import time
import os

XML_FILE_URL = "https://your-website.com/path/to/your.xml"
LOCAL_XML_PATH = "./local-copy.xml"
HASH_STORAGE_PATH = "./xml-hash.txt"

def get_remote_file_hash():
    """Fetch the remote XML's MD5 hash"""
    response = requests.get(XML_FILE_URL)
    response.raise_for_status()
    return hashlib.md5(response.content).hexdigest()

# Initialize local hash on first run
if not os.path.exists(HASH_STORAGE_PATH):
    initial_hash = get_remote_file_hash()
    with open(HASH_STORAGE_PATH, "w") as f:
        f.write(initial_hash)

while True:
    # Check hash every 5 minutes (adjust as needed)
    remote_hash = get_remote_file_hash()
    with open(HASH_STORAGE_PATH, "r") as f:
        local_hash = f.read().strip()
    
    if remote_hash != local_hash:
        # Sync the file
        response = requests.get(XML_FILE_URL)
        with open(LOCAL_XML_PATH, "wb") as f:
            f.write(response.content)
        
        # Update local hash
        with open(HASH_STORAGE_PATH, "w") as f:
            f.write(remote_hash)
        
        print("XML file updated and synced!")
    
    time.sleep(300)  # 300 seconds = 5 minutes

This uses way less bandwidth than polling the full XML, and you can set the interval to something like 15-30 minutes without missing updates.

3. Email/Message Notification Trigger #

If your web host allows sending emails or calling third-party messaging APIs, you can have the site send a notification when the XML changes. Your Python app then listens for this notification and triggers a sync.

Example: Email-based trigger #

• Step 1: On your website, send an email to a dedicated inbox after saving the XML. Use a clear subject line like "XML File Updated" so your Python app can filter it easily.
• Step 2: Use Python's imaplib to check the inbox periodically for new notifications:

import imaplib
import email
import requests
import time

EMAIL_USER = "your-sync-email@example.com"
EMAIL_PASS = "your-email-password"
XML_FILE_URL = "https://your-website.com/path/to/your.xml"
LOCAL_XML_PATH = "./local-copy.xml"

def check_for_sync_notification():
    mail = imaplib.IMAP4_SSL("imap.example.com")  # Use your email provider's IMAP server
    mail.login(EMAIL_USER, EMAIL_PASS)
    mail.select("inbox")
    
    # Search for unread emails with the trigger subject
    status, messages = mail.search(None, 'UNSEEN SUBJECT "XML File Updated"')
    if status == "OK" and messages[0]:
        for num in messages[0].split():
            # Mark the email as read
            mail.store(num, "+FLAGS", "\\Seen")
            
            # Sync the XML file
            response = requests.get(XML_FILE_URL)
            with open(LOCAL_XML_PATH, "wb") as f:
                f.write(response.content)
            
            print("Synced XML via email notification!")
    
    mail.close()
    mail.logout()

while True:
    check_for_sync_notification()
    time.sleep(60)  # Check every minute

You can also use messaging services like Telegram or Slack bots instead of email—many web hosts allow HTTP requests to these APIs, which is often more reliable than email.

4. Cloud Storage Middleman #

If you're open to using a cloud storage service (like AWS S3, Alibaba Cloud OSS, or Google Cloud Storage), you can shift the XML file to the cloud:

• When your website edits the XML, it uploads the updated version directly to the cloud storage bucket.
• Configure the cloud storage service to send a webhook or event notification to your Python app whenever the file changes.
• Your Python app receives the notification and pulls the updated file from the cloud.

Most cloud providers have built-in event notification features, and this avoids dealing with your web host's limitations entirely.

Pick the solution that fits your setup best: webhooks are ideal if you can expose your local app, hash comparison is great for low-effort, and email/messaging works for restrictive hosts.

内容的提问来源于stack exchange，提问作者K.R.