diff --git a/app.py b/app.py new file mode 100644 index 0000000..7615ee6 --- /dev/null +++ b/app.py @@ -0,0 +1,59 @@ +from flask import Flask, request, jsonify +from models import Task +from scheduler import start_scheduler, stop_scheduler, stop_specific_task, scheduled_jobs + +app = Flask(__name__) + +@app.route('/add_task', methods=['POST']) +def add_task(): + data = request.json + task, created = Task.get_or_create(name=data['name'], defaults={ + 'curl': data['curl'], + 'interval': data['interval'] + }) + if not created: + return jsonify({'error': 'Task with this name already exists'}), 400 + return jsonify({'message': 'Task added successfully'}) + +@app.route('/start_task', methods=['POST']) +def start_task(): + data = request.json + task = Task.get(Task.name == data['name']) + task.running = True + task.save() + return jsonify({'message': 'Task started successfully'}) + +@app.route('/stop_task', methods=['POST']) +def stop_task(): + data = request.json + stop_specific_task(data['name']) + return jsonify({'message': 'Task stopped successfully'}) + +@app.route('/get_tasks', methods=['GET']) +def get_tasks(): + tasks = Task.select() + task_list = [] + for task in tasks: + task_list.append({ + 'name': task.name, + 'curl': task.curl, + 'interval': task.interval, + 'running': task.running, + 'result': task.result + }) + return jsonify(task_list) + +@app.route('/stop_scheduler', methods=['GET']) +def stop(): + stop_scheduler() + return jsonify({'message': 'Scheduler stopped successfully'}) + +# stop scheduler when the app is stopped or killed +@app.teardown_appcontext +def shutdown_scheduler(exception=None): + stop_scheduler() + +if __name__ == '__main__': + start_scheduler() + app.run(debug=True) + diff --git a/get_resp.py b/get_resp.py deleted file mode 100644 index cfe1f22..0000000 --- a/get_resp.py +++ /dev/null @@ -1,102 +0,0 @@ -import uncurl -import time -import requests -import schedule -import threading - -def execute_curl(curl_command): - # Convert cURL command to Python requests code - request_code = uncurl.parse(curl_command) - request_code = f"response = {request_code}" - # Ensure response is assigned to a variable in the namespace - - # Prepare a namespace to execute the generated code - namespace = { - 'requests': requests, - 'response': None - } - - # Start timing - start_time = time.time() - - # Execute the generated request code in the given namespace - exec(request_code, namespace) - - # End timing - end_time = time.time() - # round to 4 decimal - request_time = round(end_time - start_time, 4) - - # Get the response from the namespace - response = namespace['response'] - - # Collect response details - response_details = { - 'request_time': request_time, - 'status_code': response.status_code, - 'content': response.content.decode('utf-8') # Assuming the content is in UTF-8 - } - - return response_details - - - -# Dictionary to keep track of scheduled jobs -scheduled_jobs = {} - -def schedule_curl_command(curl_command, interval_seconds, job_name): - def run_curl(): - response_details = execute_curl(curl_command) - print(response_details) - - # Schedule the run_curl function to run every interval_seconds - job = schedule.every(interval_seconds).seconds.do(run_curl) - - # Store the job in the dictionary - scheduled_jobs[job_name] = job - -def stop_specific_curl_task(job_name): - if job_name in scheduled_jobs: - schedule.cancel_job(scheduled_jobs[job_name]) - del scheduled_jobs[job_name] - -def run_schedule(): - global stop_thread - while not stop_thread: - schedule.run_pending() - time.sleep(1) - -def print_scheduled_jobs(): - jobs = schedule.get_jobs() - print(f"Currently scheduled jobs: {len(jobs)}") - for job in jobs: - print(f"Job: {job}") - -def print_running_threads(): - threads = threading.enumerate() - print(f"Currently running threads: {len(threads)}") - for thread in threads: - print(f"Thread name: {thread.name}") - -curl_command_1 = '' -# Schedule the cURL command to run every 60 seconds with job name "task1" -schedule_curl_command(curl_command_1, 60, "task1") - -# Start the schedule runner in a separate thread -schedule_thread = threading.Thread(target=run_schedule, name="schedule_thread") -schedule_thread.start() - -# Print the scheduled jobs -time.sleep(5) # Wait for a few seconds to ensure jobs are scheduled -print_scheduled_jobs() - -# Run for some time and then stop (for demonstration purposes) -time.sleep(180) # Run for 180 seconds -stop_specific_curl_task("task1") - -# Print the scheduled jobs after stopping the task -print_scheduled_jobs() - -# Stop the scheduler thread -stop_thread = True -schedule_thread.join() diff --git a/models.py b/models.py new file mode 100644 index 0000000..9698e1c --- /dev/null +++ b/models.py @@ -0,0 +1,16 @@ +from peewee import SqliteDatabase, Model, CharField, IntegerField, BooleanField, TextField + +db = SqliteDatabase('tasks.db') + +class Task(Model): + name = CharField(unique=True) + curl = TextField() + interval = IntegerField() + running = BooleanField(default=False) + result = TextField(default='') + + class Meta: + database = db + +db.connect() +db.create_tables([Task]) diff --git a/scheduler.py b/scheduler.py new file mode 100644 index 0000000..b547e49 --- /dev/null +++ b/scheduler.py @@ -0,0 +1,121 @@ +import uncurl +import time +import requests +import schedule +import threading + +from models import Task + +def execute_curl(curl_command): + # Convert cURL command to Python requests code + request_code = uncurl.parse(curl_command) + request_code = f"response = {request_code}" + # Ensure response is assigned to a variable in the namespace + + # Prepare a namespace to execute the generated code + namespace = { + 'requests': requests, + 'response': None + } + + # Start timing + start_time = time.time() + + # Execute the generated request code in the given namespace + exec(request_code, namespace) + + # End timing + end_time = time.time() + # round to 4 decimal + request_time = round(end_time - start_time, 4) + + # Get the response from the namespace + response = namespace['response'] + + # Collect response details + response_details = { + 'request_time': request_time, + 'status_code': response.status_code, + 'content': response.content.decode('utf-8') # Assuming the content is in UTF-8 + } + + return response_details + + +# Dictionary to keep track of scheduled jobs +scheduled_jobs = {} +stop_thread = False + +def run_schedule(): + global stop_thread + while not stop_thread: + for task in Task.select().where(Task.running == True): + if task.name in scheduled_jobs: + continue + job = threading.Thread(target=run_task, args=(task,)) + job.start() + scheduled_jobs[task.name] = job + time.sleep(1) + +def run_task(task): + while task.running: + result = execute_curl(task.curl) + task.result = result['content'] + task.save() + time.sleep(task.interval) + +def start_scheduler(): + global stop_thread + stop_thread = False + scheduler_thread = threading.Thread(target=run_schedule) + scheduler_thread.start() + +def stop_scheduler(): + global stop_thread + stop_thread = True + for job in scheduled_jobs.values(): + job.join() + scheduled_jobs.clear() + +def stop_specific_task(task_name): + task = Task.get(Task.name == task_name) + task.running = False + task.save() + if task_name in scheduled_jobs: + scheduled_jobs[task_name].join() + del scheduled_jobs[task_name] + +def print_scheduled_jobs(): + jobs = schedule.get_jobs() + print(f"Currently scheduled jobs: {len(jobs)}") + for job in jobs: + print(f"Job: {job}") + +def print_running_threads(): + threads = threading.enumerate() + print(f"Currently running threads: {len(threads)}") + for thread in threads: + print(f"Thread name: {thread.name}") + +# curl_command_1 = '' +# # Schedule the cURL command to run every 60 seconds with job name "task1" +# schedule_curl_command(curl_command_1, 60, "task1") + +# # Start the schedule runner in a separate thread +# schedule_thread = threading.Thread(target=run_schedule, name="schedule_thread") +# schedule_thread.start() + +# # Print the scheduled jobs +# time.sleep(5) # Wait for a few seconds to ensure jobs are scheduled +# print_scheduled_jobs() + +# # Run for some time and then stop (for demonstration purposes) +# time.sleep(180) # Run for 180 seconds +# stop_specific_curl_task("task1") + +# # Print the scheduled jobs after stopping the task +# print_scheduled_jobs() + +# # Stop the scheduler thread +# stop_thread = True +# schedule_thread.join()