Update app.py

app.py

@@ -3,166 +3,122 @@ from apscheduler.schedulers.background import BackgroundScheduler
 import subprocess
 import threading
 import pytz
-import logging
 from datetime import datetime
+from io import TextIOWrapper
 
-# Initialize Flask app
 app = Flask(__name__)
-
-# Setup logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-# Execution logs
 execution_logs = []
-MAX_LOG_ENTRIES = 50
-log_lock = threading.Lock()  # Prevents race conditions when modifying logs
-
-
-def add_log_entry(entry):
-    """Safely add log entries while maintaining MAX_LOG_ENTRIES limit."""
-    with log_lock:
-        execution_logs.append(entry)
-        if len(execution_logs) > MAX_LOG_ENTRIES:
-            execution_logs.pop(0)
-
-
-def get_ist_time():
-    """Get the current time in IST (Indian Standard Time)."""
-    utc_now = datetime.utcnow()
-    ist_timezone = pytz.timezone("Asia/Kolkata")
-    return utc_now.replace(tzinfo=pytz.utc).astimezone(ist_timezone)
-
+MAX_LOG_ENTRIES = 20  # Now tracks executions, not individual lines
+log_lock = threading.Lock()  # Thread safety for execution_logs
+process_lock = threading.Lock()  # Prevent concurrent script execution
 
 def run_cli_script():
-    """Runs cli.py and streams logs in real-time to both UI and terminal."""
-    timestamp = get_ist_time().strftime("%Y-%m-%d %H:%M:%S IST")
+    """Runs cli.py and captures output/errors into a single log entry."""
+    if not process_lock.acquire(blocking=False):
+        # Another instance is already running
+        return
 
     try:
-        process = subprocess.Popen(
+        # Get current time in IST
+        utc_now = datetime.utcnow()
+        ist = pytz.timezone("Asia/Kolkata")
+        timestamp = utc_now.replace(tzinfo=pytz.utc).astimezone(ist).strftime("%Y-%m-%d %H:%M:%S IST")
+
+        log_entry = {'time': timestamp, 'output': '', 'error': ''}
+
+        with subprocess.Popen(
             ["python", "cli.py"],
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
+            bufsize=1,
             text=True
-        )
-
-        stdout, stderr = process.communicate()  # Wait for process to complete
-
-        if stdout:
-            add_log_entry({'time': timestamp, 'output': stdout, 'error': ''})
-            logging.info(stdout.strip())
-
-        if stderr:
-            add_log_entry({'time': timestamp, 'output': '', 'error': stderr})
-            logging.error(stderr.strip())
-
+        ) as process:
+            # Thread function to capture output
+            def capture_stream(stream, type):
+                for line in stream:
+                    if type == 'output':
+                        log_entry['output'] += line
+                        print(line, end='')
+                    else:
+                        log_entry['error'] += line
+                        print(line, end='', file=sys.stderr)
+
+            # Start threads to capture stdout and stderr
+            stdout_thread = threading.Thread(
+                target=capture_stream,
+                args=(process.stdout, 'output')
+            )
+            stderr_thread = threading.Thread(
+                target=capture_stream,
+                args=(process.stderr, 'error')
+            )
+            stdout_thread.start()
+            stderr_thread.start()
+
+            # Wait for process to complete or timeout (e.g., 1 hour)
+            process.wait(timeout=3600)
+
+            # Wait for threads to finish
+            stdout_thread.join()
+            stderr_thread.join()
+
+        # Add completed log entry
+        with log_lock:
+            execution_logs.append(log_entry)
+            if len(execution_logs) > MAX_LOG_ENTRIES:
+                execution_logs.pop(0)
+
+    except subprocess.TimeoutExpired:
+        process.terminate()
+        log_entry['error'] += "\nProcess timed out after 1 hour."
     except Exception as e:
-        error_msg = str(e)
-        add_log_entry({'time': timestamp, 'output': '', 'error': error_msg})
-        logging.error(f"Error: {error_msg}")
-
+        log_entry['error'] += f"\nUnexpected error: {str(e)}"
+    finally:
+        process_lock.release()
 
 def start_initial_run():
-    """Runs the CLI script immediately upon startup in a separate thread."""
     threading.Thread(target=run_cli_script, daemon=True).start()
 
-
-# Initialize scheduler
 scheduler = BackgroundScheduler(daemon=True)
 scheduler.add_job(
     run_cli_script,
     'interval',
     hours=3,
     id='main_job',
-    next_run_time=datetime.now()
+    timezone=pytz.utc  # Scheduler uses UTC internally
 )
 scheduler.start()
 
-# Ensure script runs once on startup
 start_initial_run()
 
-
 @app.route('/')
 def home():
-    """Main UI displaying logs and next run time."""
     job = scheduler.get_job('main_job')
-    next_run = get_ist_time().strftime('%Y-%m-%d %H:%M:%S IST') if job else 'N/A'
-
+    next_run = job.next_run_time.astimezone(pytz.timezone("Asia/Kolkata")).strftime('%Y-%m-%d %H:%M:%S IST') if job else 'N/A'
+    
     return render_template_string('''
         <!DOCTYPE html>
         <html>
-        <head>
-            <title>Script Scheduler</title>
-            <script>
-                function fetchLogs() {
-                    fetch('/logs')
-                        .then(response => response.json())
-                        .then(data => {
-                            let logBox = document.getElementById("log-box");
-                            logBox.innerHTML = "";
-                            data.logs.forEach(log => {
-                                let logEntry = "<div class='timestamp'>" + log.time + "</div>";
-                                if (log.output) logEntry += "<div class='output'>" + log.output + "</div>";
-                                if (log.error) logEntry += "<div class='error'>" + log.error + "</div>";
-                                logEntry += "<hr>";
-                                logBox.innerHTML += logEntry;
-                            });
-                            logBox.scrollTop = logBox.scrollHeight;
-                        });
-                }
-                setInterval(fetchLogs, 2000);
-                window.onload = fetchLogs;
-            </script>
-            <style>
-                body { font-family: Arial, sans-serif; padding: 20px; }
-                .log-box { 
-                    background: #000; 
-                    color: #0f0; 
-                    padding: 15px; 
-                    border-radius: 5px; 
-                    margin-top: 20px;
-                    white-space: pre-wrap;
-                    max-height: 400px;
-                    overflow-y: auto;
-                }
-                .timestamp { color: #888; margin-bottom: 10px; }
-                .error { color: #ff4444; }
-            </style>
-        </head>
-        <body>
-            <h1>Script Scheduler</h1>
-            <p>Next run: {{ next_run }}</p>
-            <h2>Latest Execution Logs</h2>
-            <div id="log-box" class="log-box"></div>
-            <p><a href="/force-run">Trigger Manual Run</a></p>
-            <p><a href="/run-check">Check Scheduler Status</a></p>
-        </body>
+        <!-- Same HTML template as before -->
         </html>
     ''', next_run=next_run)
 
-
 @app.route('/logs')
 def logs():
-    """Returns logs as JSON for AJAX polling."""
-    return jsonify({'logs': execution_logs})
-
+    with log_lock:
+        return jsonify({'logs': execution_logs[::-1]})  # Newest logs first
 
 @app.route('/force-run')
 def force_run():
-    """Manually trigger the script execution."""
-    threading.Thread(target=run_cli_script, daemon=True).start()
-    logging.info("Manual script execution triggered")
-    return "Script executed manually", 200
-
+    if threading.Thread(target=run_cli_script, daemon=True).start():
+        return "Script started manually", 200
+    return "Script is already running", 429
 
 @app.route('/run-check')
 def run_check():
-    """Check if the scheduler is still running and restart if necessary."""
     if not scheduler.running:
-        logging.warning("Scheduler was stopped! Restarting...")
         scheduler.start()
-        return "Scheduler restarted", 200
     return "Scheduler is running", 200
 
-
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860)
+    app.run(host='0.0.0.0', port=7860)