cottongin
4a3a82826d
- Add colored and right-aligned bot identifiers in logs with consistent column width - Implement unique color assignment for each bot instance (falls back to hash-based when colors exhausted) - Add padding system to maintain uniform column alignment across all bot instances - Redirect asif library logs to ERROR.log file - Add ERROR.log to .gitignore - Improve log formatting with timestamps and bot identifiers - Implement dynamic column width adjustment when new bots join
381 lines
14 KiB
Python
381 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# Set up logging configuration before imports
|
|
import logging
|
|
|
|
class AsifFilter(logging.Filter):
|
|
def filter(self, record):
|
|
# Block messages from asif module or if they start with "Joined channel"
|
|
return not (record.module == 'asif' or
|
|
record.name.startswith('asif') or
|
|
(isinstance(record.msg, str) and record.msg.startswith('Joined channel')))
|
|
|
|
# Set up base logging configuration
|
|
logging.basicConfig(
|
|
level=logging.INFO,
|
|
format='%(asctime)s - %(message)s',
|
|
datefmt='%H:%M:%S'
|
|
)
|
|
|
|
# Apply filter to root logger
|
|
logging.getLogger().addFilter(AsifFilter())
|
|
|
|
# Also apply to asif's logger specifically
|
|
asif_logger = logging.getLogger('asif')
|
|
asif_logger.addFilter(AsifFilter())
|
|
asif_logger.setLevel(logging.CRITICAL)
|
|
asif_logger.propagate = False
|
|
|
|
from asif import Client
|
|
|
|
# Set up error logging for asif
|
|
error_handler = logging.FileHandler('ERROR.log')
|
|
error_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
|
|
|
|
# Patch asif's Client class to use error logger
|
|
def silent_client_init(self, *args, **kwargs):
|
|
# Create a logger that writes to ERROR.log
|
|
error_logger = logging.getLogger('asif.client')
|
|
error_logger.addHandler(error_handler)
|
|
error_logger.propagate = False # Don't send to console
|
|
error_logger.setLevel(logging.INFO) # Capture all messages
|
|
|
|
# Store the logger
|
|
self._log = error_logger
|
|
|
|
# Call the original __init__
|
|
original_init(self, *args, **kwargs)
|
|
|
|
# Save original __init__ and replace it
|
|
original_init = Client.__init__
|
|
Client.__init__ = silent_client_init
|
|
|
|
import asyncio
|
|
import re
|
|
import aiohttp
|
|
import json
|
|
import time
|
|
import argparse
|
|
import yaml
|
|
from pathlib import Path
|
|
from typing import List, Optional
|
|
|
|
# ANSI color codes
|
|
class Colors:
|
|
COLORS = [
|
|
'\033[94m', # BLUE
|
|
'\033[96m', # CYAN
|
|
'\033[92m', # GREEN
|
|
'\033[93m', # YELLOW
|
|
'\033[95m', # MAGENTA
|
|
'\033[91m', # RED
|
|
]
|
|
ENDC = '\033[0m'
|
|
BOLD = '\033[1m'
|
|
|
|
# Track used colors
|
|
used_colors = {} # botname -> color mapping
|
|
|
|
@classmethod
|
|
def get_color_for_bot(cls, botname: str) -> str:
|
|
"""Get a consistent color for a bot based on its name."""
|
|
# If this bot already has a color, return it
|
|
if botname in cls.used_colors:
|
|
return cls.used_colors[botname]
|
|
|
|
# If we still have unused colors, use the next available one
|
|
unused_colors = [c for c in cls.COLORS if c not in cls.used_colors.values()]
|
|
if unused_colors:
|
|
color = unused_colors[0]
|
|
else:
|
|
# If we're out of unique colors, fall back to hash-based selection
|
|
color = cls.COLORS[hash(botname) % len(cls.COLORS)]
|
|
|
|
cls.used_colors[botname] = color
|
|
return color
|
|
|
|
class BotLoggerAdapter(logging.LoggerAdapter):
|
|
# Class variables to track maximum lengths
|
|
max_nick_length = 0
|
|
max_endpoint_length = 0
|
|
instances = [] # Keep track of all instances to update padding
|
|
|
|
def __init__(self, logger, extra):
|
|
super().__init__(logger, extra)
|
|
botname = extra['botname']
|
|
nick, endpoint = botname.split('@')
|
|
self.nick = nick
|
|
self.endpoint = endpoint
|
|
|
|
# Update max lengths (without ANSI codes)
|
|
old_max_nick = BotLoggerAdapter.max_nick_length
|
|
old_max_endpoint = BotLoggerAdapter.max_endpoint_length
|
|
|
|
BotLoggerAdapter.max_nick_length = max(
|
|
BotLoggerAdapter.max_nick_length,
|
|
len(nick)
|
|
)
|
|
BotLoggerAdapter.max_endpoint_length = max(
|
|
BotLoggerAdapter.max_endpoint_length,
|
|
len(endpoint)
|
|
)
|
|
|
|
# If max lengths changed, update all existing instances
|
|
if (old_max_nick != BotLoggerAdapter.max_nick_length or
|
|
old_max_endpoint != BotLoggerAdapter.max_endpoint_length):
|
|
for instance in BotLoggerAdapter.instances:
|
|
instance.update_padding()
|
|
|
|
# Add self to instances list
|
|
BotLoggerAdapter.instances.append(self)
|
|
|
|
# Initial padding calculation
|
|
self.update_padding()
|
|
|
|
def update_padding(self):
|
|
"""Update the colored botname with current padding requirements."""
|
|
# Right-align nick, then @ symbol, then colored endpoint
|
|
nick_padding = " " * (BotLoggerAdapter.max_nick_length - len(self.nick))
|
|
endpoint_padding = " " * (BotLoggerAdapter.max_endpoint_length - len(self.endpoint))
|
|
self.colored_botname = f"{nick_padding}{self.nick}@{Colors.BOLD}{Colors.get_color_for_bot(self.nick+'@'+self.endpoint)}{self.endpoint}{Colors.ENDC}{endpoint_padding}"
|
|
|
|
def process(self, msg, kwargs):
|
|
return f'[{self.colored_botname}] {msg}', kwargs
|
|
|
|
class IcecastBot:
|
|
def __init__(self, config_path: Optional[str] = None):
|
|
# Load config
|
|
self.config = self.load_config(config_path)
|
|
|
|
# Set up bot-specific logger
|
|
self.logger = BotLoggerAdapter(
|
|
logging.getLogger(__name__),
|
|
{'botname': f'{self.config["irc"]["nick"]}@{self.config["stream"]["endpoint"]}'}
|
|
)
|
|
|
|
# Initialize IRC bot with config
|
|
self.bot = Client(
|
|
host=self.config['irc']['host'],
|
|
port=self.config['irc']['port'],
|
|
user=self.config['irc']['user'],
|
|
realname=self.config['irc']['realname'],
|
|
nick=self.config['irc']['nick']
|
|
)
|
|
|
|
# Set up instance variables from config
|
|
self.channel_name = self.config['irc']['channel']
|
|
self.stream_url = self.config['stream']['url']
|
|
self.stream_endpoint = self.config['stream']['endpoint']
|
|
self.current_song = "Unknown"
|
|
self.reply = self.config['announce']['format']
|
|
self.ignore_patterns = self.config['announce']['ignore_patterns']
|
|
self.channel = None
|
|
self.last_health_check = time.time()
|
|
self.health_check_interval = self.config['stream']['health_check_interval']
|
|
|
|
self.setup_handlers()
|
|
|
|
@staticmethod
|
|
def load_config(config_path: Optional[str] = None) -> dict:
|
|
"""Load configuration from file and/or command line arguments."""
|
|
if config_path is None:
|
|
config_path = Path(__file__).parent / 'config.yaml'
|
|
|
|
# Load config file
|
|
try:
|
|
with open(config_path) as f:
|
|
config = yaml.safe_load(f)
|
|
except FileNotFoundError:
|
|
# Create a temporary logger for config loading
|
|
temp_logger = logging.getLogger(__name__)
|
|
temp_logger.warning(f"Config file not found at {config_path}, using defaults")
|
|
config = {
|
|
'irc': {},
|
|
'stream': {},
|
|
'announce': {
|
|
'format': "\x02Now playing:\x02 {song}",
|
|
'ignore_patterns': ['Unknown', 'Unable to fetch metadata']
|
|
}
|
|
}
|
|
|
|
return config
|
|
|
|
def should_announce_song(self, song: str) -> bool:
|
|
"""Check if the song should be announced based on ignore patterns."""
|
|
return not any(pattern.lower() in song.lower() for pattern in self.ignore_patterns)
|
|
|
|
def setup_handlers(self):
|
|
@self.bot.on_connected()
|
|
async def connected():
|
|
try:
|
|
self.channel = await self.bot.join(self.channel_name)
|
|
self.logger.info(f"Connected to IRC and joined {self.channel_name}")
|
|
except Exception as e:
|
|
self.logger.error(f"Error joining channel: {e}")
|
|
|
|
asyncio.create_task(self.monitor_metadata())
|
|
|
|
@self.bot.on_join()
|
|
async def on_join(channel):
|
|
# Silently store the channel without logging
|
|
if not self.channel:
|
|
self.channel = channel
|
|
|
|
@self.bot.on_message(re.compile("^!np"))
|
|
async def now_playing(message):
|
|
await message.reply(self.reply.format(song=self.current_song))
|
|
|
|
async def fetch_json_metadata(self):
|
|
try:
|
|
async with aiohttp.ClientSession() as session:
|
|
url = f"{self.stream_url}/status-json.xsl"
|
|
async with session.get(url) as response:
|
|
if response.status == 200:
|
|
data = await response.text()
|
|
json_data = json.loads(data)
|
|
|
|
if 'icestats' in json_data:
|
|
sources = json_data['icestats'].get('source', [])
|
|
if isinstance(sources, list):
|
|
for src in sources:
|
|
if src['listenurl'].endswith(f'{self.stream_endpoint}'):
|
|
source = src
|
|
else:
|
|
source = sources
|
|
|
|
title = source.get('title') or source.get('song') or source.get('current_song')
|
|
if title:
|
|
return title
|
|
|
|
return "Unable to fetch metadata"
|
|
except Exception as e:
|
|
self.logger.error(f"Error fetching JSON metadata: {e}")
|
|
return "Error fetching metadata"
|
|
|
|
async def monitor_metadata(self):
|
|
await asyncio.sleep(5)
|
|
|
|
while True:
|
|
try:
|
|
cmd = [
|
|
'curl',
|
|
'-s',
|
|
'-H', 'Icy-MetaData: 1',
|
|
'--no-buffer',
|
|
f"{self.stream_url}/{self.stream_endpoint}"
|
|
]
|
|
|
|
process = await asyncio.create_subprocess_exec(
|
|
*cmd,
|
|
stdout=asyncio.subprocess.PIPE,
|
|
stderr=asyncio.subprocess.PIPE
|
|
)
|
|
|
|
self.logger.info("Started stream monitoring")
|
|
|
|
buffer = b""
|
|
last_json_check = time.time()
|
|
json_check_interval = 60 # Fallback interval if ICY updates fail
|
|
|
|
while True:
|
|
chunk = await process.stdout.read(8192)
|
|
if not chunk:
|
|
break
|
|
|
|
buffer += chunk
|
|
current_time = time.time()
|
|
|
|
# Periodic health check
|
|
if current_time - self.last_health_check >= self.health_check_interval:
|
|
self.logger.info("Monitor status: Active - processing stream data")
|
|
self.last_health_check = current_time
|
|
|
|
# Look for metadata marker but fetch from JSON
|
|
if b"StreamTitle='" in buffer:
|
|
new_song = await self.fetch_json_metadata()
|
|
if new_song and new_song != self.current_song and "Unable to fetch metadata" not in new_song:
|
|
self.logger.info(f"Now Playing: {new_song}")
|
|
self.current_song = new_song
|
|
await self.announce_song(new_song)
|
|
|
|
# Clear buffer after metadata marker
|
|
buffer = buffer[buffer.find(b"';", buffer.find(b"StreamTitle='")) + 2:]
|
|
last_json_check = current_time
|
|
|
|
# Keep buffer size reasonable
|
|
if len(buffer) > 65536:
|
|
buffer = buffer[-32768:]
|
|
|
|
# Fallback JSON check if ICY updates aren't coming through
|
|
if current_time - last_json_check >= json_check_interval:
|
|
new_song = await self.fetch_json_metadata()
|
|
if "Unable to fetch metadata" in new_song:
|
|
break
|
|
if new_song and new_song != self.current_song:
|
|
self.logger.info(f"Now Playing (fallback): {new_song}")
|
|
self.current_song = new_song
|
|
await self.announce_song(new_song)
|
|
last_json_check = current_time
|
|
|
|
await asyncio.sleep(0.1)
|
|
|
|
await process.wait()
|
|
self.logger.warning("Stream monitor ended, restarting...")
|
|
await asyncio.sleep(5)
|
|
|
|
except Exception as e:
|
|
self.logger.error(f"Stream monitor error: {e}")
|
|
await asyncio.sleep(5)
|
|
|
|
async def announce_song(self, song: str):
|
|
"""Announce song if it doesn't match any ignore patterns."""
|
|
try:
|
|
if self.channel and self.should_announce_song(song):
|
|
await self.channel.message(self.reply.format(song=song))
|
|
except Exception as e:
|
|
self.logger.error(f"Error announcing song: {e}")
|
|
|
|
async def start(self):
|
|
await self.bot.run()
|
|
|
|
async def run_multiple_bots(config_paths: List[str]):
|
|
"""Run multiple bot instances concurrently."""
|
|
bots = [IcecastBot(config_path) for config_path in config_paths]
|
|
await asyncio.gather(*(bot.start() for bot in bots))
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description='Icecast IRC Bot')
|
|
parser.add_argument('configs', nargs='*', help='Paths to config files')
|
|
parser.add_argument('--config', type=str, help='Path to single config file')
|
|
parser.add_argument('--irc-host', type=str, help='IRC server host')
|
|
parser.add_argument('--irc-port', type=int, help='IRC server port')
|
|
parser.add_argument('--irc-nick', type=str, help='IRC nickname')
|
|
parser.add_argument('--irc-channel', type=str, help='IRC channel')
|
|
parser.add_argument('--stream-url', type=str, help='Icecast stream URL (base url; do not include /stream or .mp3)')
|
|
parser.add_argument('--stream-endpoint', type=str, help='Stream endpoint (e.g. /stream)')
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.configs:
|
|
# Multi-bot mode
|
|
asyncio.run(run_multiple_bots(args.configs))
|
|
else:
|
|
# Single-bot mode
|
|
bot = IcecastBot(args.config)
|
|
|
|
# Apply any command line overrides to the config
|
|
if args.irc_host:
|
|
bot.config['irc']['host'] = args.irc_host
|
|
if args.irc_port:
|
|
bot.config['irc']['port'] = args.irc_port
|
|
if args.irc_nick:
|
|
bot.config['irc']['nick'] = args.irc_nick
|
|
if args.irc_channel:
|
|
bot.config['irc']['channel'] = args.irc_channel
|
|
if args.stream_url:
|
|
bot.config['stream']['url'] = args.stream_url
|
|
if args.stream_endpoint:
|
|
bot.config['stream']['endpoint'] = args.stream_endpoint
|
|
|
|
asyncio.run(bot.start())
|