Développez un système qui surveille un fichier journal situé sur un serveur distant, similaire à la commande Unix tail -f.-Tutoriel Python-php.cn

Développez un système qui surveille un fichier journal situé sur un serveur distant, similaire à la commande Unix tail -f.

Barbara Streisand

Libérer： 2024-09-28 22:11:02

original

847 Les gens l'ont consulté

Develop a system that monitors a log file located on a remote server, similar to the Unix command tail -f.

L'objectif de ce problème est :
L'objectif est de développer un système qui surveille un fichier journal situé sur un serveur distant, similaire à la commande Unix tail -f. Le fichier journal est continuellement complété par de nouvelles données. Ce système devrait être composé de :

Une application serveur qui suit les modifications en cours dans un fichier journal spécifié situé sur le même serveur. Cette application devrait être capable de transmettre les données nouvellement ajoutées en temps réel aux clients.
Une interface client Web, accessible via une URL (par exemple, http://localhost/log), conçue pour afficher les mises à jour des fichiers journaux de manière dynamique au fur et à mesure qu'elles se produisent, sans que l'utilisateur ait à recharger la page. Initialement, lors de la visite de la page, les utilisateurs devraient voir les 10 lignes les plus récentes du fichier journal.
Géré également les scénarios suivants :
Le serveur doit activement transmettre les mises à jour aux clients pour garantir un délai minimal et obtenir des mises à jour aussi proches que possible du temps réel.
Étant donné que le fichier journal peut être très volumineux (potentiellement plusieurs gigaoctets), vous devrez développer une stratégie pour récupérer efficacement les 10 dernières lignes sans traiter l'intégralité du fichier.
Le serveur doit transmettre uniquement les nouveaux ajouts au fichier aux clients, plutôt que de renvoyer le fichier dans son intégralité.
Il est essentiel que le serveur prenne en charge les connexions simultanées de plusieurs clients sans dégradation des performances.
La page Web du client doit se charger rapidement sans rester en état de chargement après la demande initiale, et elle ne doit pas nécessiter de rechargement pour afficher les nouvelles mises à jour.

J'ai créé une application Flask avec une interface utilisateur simple qui affiche les 10 derniers messages.

J'ai utilisé le flask-socketio pour établir une connexion et j'ai également utilisé quelques concepts de base de gestion de fichiers comme fileObj.seek(), fileObj.tell() etc.

from flask import Flask, render_template
from flask_socketio import SocketIO, emit
from threading import Lock

app = Flask(__name__)
socketio = SocketIO(app)
thread = None
thread_lock = Lock()
LOG_FILE_PATH = "./static/client.txt"
last_position = 0
position_lock = Lock()

@app.route('/')
def index():
    return render_template('index.html')

@socketio.on('connect')
def test_connect():
    global thread
    with thread_lock:
        if thread is None:
            print("started execution in background!")
            thread = socketio.start_background_task(target=monitor_log_file)

def monitor_log_file():
    global last_position
    while True:
        try:
            with open(LOG_FILE_PATH, 'rb') as f:
                f.seek(0, 2)
                file_size = f.tell()
                if last_position != file_size:
                    buffer_size = 1024
                    if file_size < buffer_size:
                        buffer_size = file_size
                    f.seek(-buffer_size, 2)
                    lines = f.readlines()
                    last_lines = lines[-10:]
                    content = b'\n'.join(last_lines).decode('utf-8')
                    socketio.sleep(1)  # Add a small delay to prevent high CPU usage
                    socketio.emit('log_updates', {'content': content})
                    print("Emitted new Lines to Client!")
                    last_position = file_size
                else:
                    pass
        except FileNotFoundError:
            print(f"Error: {LOG_FILE_PATH} not found.")
        except Exception as e:
            print(f"Error while reading the file: {e}")

if __name__ == '__main__':
    socketio.run(app, debug=True, log_output=True, use_reloader=False)

Copier après la connexion

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Basics</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.5.4/socket.io.js"></script>
</head>
<body>
<h1>User Updated Files Display it over here:</h1>
<div id="output"></div>

<script>
    var socket = io("http://127.0.0.1:5000");
    socket.on('connect', function() {
        console.log('Connected to the server');
    });
    socket.on('disconnect', function() {
        console.log('Client disconnected');
    });
    socket.on('log_updates', function(data) {
        console.log("data", data);
        var div = document.getElementById('output');
        var lines = data.content.split('\n');
        div.innerHTML = '';
        lines.forEach(function(line) {
            var p = document.createElement('p');
            p.textContent = line;
            div.appendChild(p);
        });
    });
</script>
</body>
</html>

Copier après la connexion

Créez également un fichier client.log sous le dossier statique dans l'application flask.
N'hésitez pas à me corriger si j'ai fait quelque chose de mal. Commentez ci-dessous avec d’éventuelles corrections !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!