151 lines
3.8 KiB
Python
151 lines
3.8 KiB
Python
import os
|
|
import requests
|
|
from datetime import datetime, timedelta, UTC
|
|
from zoneinfo import ZoneInfo
|
|
from pymongo import MongoClient
|
|
from dotenv import load_dotenv
|
|
from pymongo.errors import PyMongoError
|
|
from apscheduler.schedulers.blocking import BlockingScheduler
|
|
|
|
load_dotenv()
|
|
|
|
# Configuration
|
|
ENDPOINT_URL = os.getenv("ENDPOINT_URL")
|
|
MONGO_URI = os.getenv("MONGO_URI")
|
|
DB_NAME = os.getenv("DB_NAME")
|
|
COLLECTION_NAME = os.getenv("COLLECTION_NAME")
|
|
TIMEZONE = ZoneInfo("Europe/Rome")
|
|
|
|
|
|
def get_time_range():
|
|
"""
|
|
Calculate the time range for the current execution.
|
|
Returns a tuple of (min_timestamp, max_timestamp) in ISO 8601 format with Europe/Rome timezone.
|
|
"""
|
|
now = datetime.now(TIMEZONE)
|
|
one_minute_ago = now - timedelta(minutes=1)
|
|
|
|
# Format with colon in timezone offset (e.g., +01:00 instead of +0100)
|
|
def format_with_colon(dt):
|
|
base = dt.strftime("%Y-%m-%dT%H:%M:%S")
|
|
# Get timezone offset and format with colon
|
|
offset = dt.strftime("%z")
|
|
if offset:
|
|
sign = offset[0]
|
|
hours = offset[1:3]
|
|
minutes = offset[3:5]
|
|
return f"{base}{sign}{hours}:{minutes}"
|
|
return base
|
|
|
|
min_timestamp = format_with_colon(one_minute_ago)
|
|
max_timestamp = format_with_colon(now)
|
|
|
|
return min_timestamp, max_timestamp
|
|
|
|
|
|
def fetch_plexts(min_timestamp, max_timestamp):
|
|
"""
|
|
Fetch plexts from the endpoint.
|
|
|
|
Args:
|
|
min_timestamp: Start timestamp in ISO 8601 format
|
|
max_timestamp: End timestamp in ISO 8601 format
|
|
|
|
Returns:
|
|
List of plexts or None if error occurs
|
|
"""
|
|
try:
|
|
params = {"min_timestamp": min_timestamp, "max_timestamp": max_timestamp}
|
|
response = requests.get(ENDPOINT_URL, params=params, timeout=30)
|
|
response.raise_for_status()
|
|
data = response.json()
|
|
return data.get("plexts", [])
|
|
except requests.RequestException as e:
|
|
print(f"Error fetching plexts: {e}")
|
|
return None
|
|
|
|
|
|
def save_to_mongodb(plexts):
|
|
"""
|
|
Save plexts to MongoDB.
|
|
|
|
Args:
|
|
plexts: List of plext dictionaries to save
|
|
|
|
Returns:
|
|
True if successful, False otherwise
|
|
"""
|
|
if not plexts:
|
|
print("No plexts to save")
|
|
return True
|
|
|
|
try:
|
|
client = MongoClient(MONGO_URI)
|
|
db = client[DB_NAME]
|
|
collection = db[COLLECTION_NAME]
|
|
|
|
# Insert all plexts
|
|
result = collection.insert_many(plexts)
|
|
print(f"Inserted {len(result.inserted_ids)} plexts to MongoDB")
|
|
return True
|
|
except PyMongoError as e:
|
|
print(f"Error saving to MongoDB: {e}")
|
|
return False
|
|
finally:
|
|
client.close()
|
|
|
|
|
|
def job():
|
|
"""
|
|
Main job function that runs every minute.
|
|
"""
|
|
print(
|
|
f"\n[{datetime.now(TIMEZONE).strftime('%Y-%m-%d %H:%M:%S %Z')}] Starting job..."
|
|
)
|
|
|
|
# Get time range
|
|
min_timestamp, max_timestamp = get_time_range()
|
|
print(f"Time range: {min_timestamp} to {max_timestamp}")
|
|
|
|
# Fetch plexts
|
|
plexts = fetch_plexts(min_timestamp, max_timestamp)
|
|
|
|
if plexts is None:
|
|
print("Failed to fetch plexts")
|
|
return
|
|
|
|
print(f"Fetched {len(plexts)} plexts")
|
|
|
|
# Save to MongoDB
|
|
if save_to_mongodb(plexts):
|
|
print("Job completed successfully")
|
|
else:
|
|
print("Job completed with errors")
|
|
|
|
|
|
def main():
|
|
"""
|
|
Main function to schedule and run the job.
|
|
"""
|
|
print("Starting Plex monitoring scheduler...")
|
|
print("Press Ctrl+C to stop")
|
|
|
|
# Create scheduler
|
|
scheduler = BlockingScheduler()
|
|
|
|
# Schedule job to run every minute
|
|
scheduler.add_job(job, "interval", minutes=1)
|
|
|
|
# Run the job immediately on startup
|
|
job()
|
|
|
|
# Start the scheduler
|
|
try:
|
|
scheduler.start()
|
|
except (KeyboardInterrupt, SystemExit):
|
|
print("\nScheduler stopped by user")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|