308 lines
10 KiB
Python
308 lines
10 KiB
Python
#!/usr/local/bin/python
|
|
import logging
|
|
import logging.config
|
|
import json
|
|
import time
|
|
import datetime
|
|
import os
|
|
import sys
|
|
import hashlib
|
|
import json
|
|
import shutil
|
|
|
|
from subprocess import Popen, PIPE, STDOUT
|
|
|
|
from configobj import ConfigObj
|
|
|
|
import mutagen
|
|
import pyinotify
|
|
from pyinotify import WatchManager, Notifier, ProcessEvent
|
|
|
|
# For RabbitMQ
|
|
from kombu.connection import BrokerConnection
|
|
from kombu.messaging import Exchange, Queue, Consumer, Producer
|
|
from api_clients import api_client
|
|
|
|
global storage_directory
|
|
storage_directory = "/srv/airtime/stor"
|
|
|
|
# configure logging
|
|
try:
|
|
logging.config.fileConfig("logging.cfg")
|
|
except Exception, e:
|
|
print 'Error configuring logging: ', e
|
|
sys.exit()
|
|
|
|
# loading config file
|
|
try:
|
|
config = ConfigObj('/etc/airtime/media-monitor.cfg')
|
|
except Exception, e:
|
|
logger = logging.getLogger();
|
|
logger.error('Error loading config file: %s', e)
|
|
sys.exit()
|
|
|
|
"""
|
|
list of supported easy tags in mutagen version 1.20
|
|
['albumartistsort', 'musicbrainz_albumstatus', 'lyricist', 'releasecountry', 'date', 'performer', 'musicbrainz_albumartistid', 'composer', 'encodedby', 'tracknumber', 'musicbrainz_albumid', 'album', 'asin', 'musicbrainz_artistid', 'mood', 'copyright', 'author', 'media', 'length', 'version', 'artistsort', 'titlesort', 'discsubtitle', 'website', 'musicip_fingerprint', 'conductor', 'compilation', 'barcode', 'performer:*', 'composersort', 'musicbrainz_discid', 'musicbrainz_albumtype', 'genre', 'isrc', 'discnumber', 'musicbrainz_trmid', 'replaygain_*_gain', 'musicip_puid', 'artist', 'title', 'bpm', 'musicbrainz_trackid', 'arranger', 'albumsort', 'replaygain_*_peak', 'organization']
|
|
"""
|
|
|
|
|
|
def checkRabbitMQ(notifier):
|
|
try:
|
|
notifier.connection.drain_events(timeout=int(config["check_airtime_events"]))
|
|
except Exception, e:
|
|
logger = logging.getLogger('root')
|
|
logger.info("%s", e)
|
|
|
|
class AirtimeNotifier(Notifier):
|
|
|
|
def __init__(self, watch_manager, default_proc_fun=None, read_freq=0, threshold=0, timeout=None):
|
|
Notifier.__init__(self, watch_manager, default_proc_fun, read_freq, threshold, timeout)
|
|
|
|
self.airtime2mutagen = {\
|
|
"track_title": "title",\
|
|
"artist_name": "artist",\
|
|
"album_title": "album",\
|
|
"genre": "genre",\
|
|
"mood": "mood",\
|
|
"track_number": "tracknumber",\
|
|
"bpm": "bpm",\
|
|
"label": "organization",\
|
|
"composer": "composer",\
|
|
"encoded_by": "encodedby",\
|
|
"conductor": "conductor",\
|
|
"year": "date",\
|
|
"info_url": "website",\
|
|
"isrc_number": "isrc",\
|
|
"copyright": "copyright",\
|
|
}
|
|
|
|
schedule_exchange = Exchange("airtime-media-monitor", "direct", durable=True, auto_delete=True)
|
|
schedule_queue = Queue("media-monitor", exchange=schedule_exchange, key="filesystem")
|
|
self.connection = BrokerConnection(config["rabbitmq_host"], config["rabbitmq_user"], config["rabbitmq_password"], "/")
|
|
channel = self.connection.channel()
|
|
consumer = Consumer(channel, schedule_queue)
|
|
consumer.register_callback(self.handle_message)
|
|
consumer.consume()
|
|
|
|
def handle_message(self, body, message):
|
|
# ACK the message to take it off the queue
|
|
message.ack()
|
|
|
|
logger = logging.getLogger('root')
|
|
logger.info("Received md from RabbitMQ: " + body)
|
|
|
|
m = json.loads(message.body)
|
|
airtime_file = mutagen.File(m['filepath'], easy=True)
|
|
del m['filepath']
|
|
for key in m.keys() :
|
|
if m[key] != "" :
|
|
airtime_file[self.airtime2mutagen[key]] = m[key]
|
|
|
|
airtime_file.save()
|
|
|
|
class MediaMonitor(ProcessEvent):
|
|
|
|
def my_init(self):
|
|
"""
|
|
Method automatically called from ProcessEvent.__init__(). Additional
|
|
keyworded arguments passed to ProcessEvent.__init__() are then
|
|
delegated to my_init().
|
|
"""
|
|
self.api_client = api_client.api_client_factory(config)
|
|
|
|
self.mutagen2airtime = {\
|
|
"title": "track_title",\
|
|
"artist": "artist_name",\
|
|
"album": "album_title",\
|
|
"genre": "genre",\
|
|
"mood": "mood",\
|
|
"tracknumber": "track_number",\
|
|
"bpm": "bpm",\
|
|
"organization": "label",\
|
|
"composer": "composer",\
|
|
"encodedby": "encoded_by",\
|
|
"conductor": "conductor",\
|
|
"date": "year",\
|
|
"website": "info_url",\
|
|
"isrc": "isrc_number",\
|
|
"copyright": "copyright",\
|
|
}
|
|
|
|
self.supported_file_formats = ['mp3', 'ogg']
|
|
self.logger = logging.getLogger('root')
|
|
self.temp_files = {}
|
|
self.imported_renamed_files = {}
|
|
|
|
def get_md5(self, filepath):
|
|
f = open(filepath, 'rb')
|
|
m = hashlib.md5()
|
|
m.update(f.read())
|
|
md5 = m.hexdigest()
|
|
|
|
return md5
|
|
|
|
def ensure_dir(self, filepath):
|
|
|
|
directory = os.path.dirname(filepath)
|
|
|
|
if ((not os.path.exists(directory)) or ((os.path.exists(directory) and not os.path.isdir(directory)))):
|
|
os.makedirs(directory, 02775)
|
|
|
|
def create_unique_filename(self, filepath):
|
|
|
|
file_dir = os.path.dirname(filepath)
|
|
filename = os.path.basename(filepath).split(".")[0]
|
|
file_ext = os.path.splitext(filepath)[1]
|
|
|
|
if(os.path.exists(filepath)):
|
|
i = 1;
|
|
while(True):
|
|
new_filepath = "%s/%s(%s).%s" % (file_dir, filename, i, file_ext)
|
|
|
|
if(os.path.exists(new_filepath)):
|
|
i = i+1;
|
|
else:
|
|
filepath = new_filepath
|
|
|
|
self.imported_renamed_files[filepath] = 0
|
|
|
|
return filepath
|
|
|
|
def create_file_path(self, imported_filepath):
|
|
|
|
global storage_directory
|
|
|
|
original_name = os.path.basename(imported_filepath)
|
|
file_ext = os.path.splitext(imported_filepath)[1]
|
|
file_info = mutagen.File(imported_filepath, easy=True)
|
|
|
|
metadata = {'artist':None,
|
|
'album':None,
|
|
'title':None,
|
|
'tracknumber':None}
|
|
|
|
for key in metadata.keys():
|
|
if key in file_info:
|
|
metadata[key] = file_info[key][0]
|
|
|
|
if metadata['artist'] is not None:
|
|
base = "%s/%s" % (storage_directory, metadata['artist'])
|
|
if metadata['album'] is not None:
|
|
base = "%s/%s" % (base, metadata['album'])
|
|
if metadata['title'] is not None:
|
|
if metadata['tracknumber'] is not None:
|
|
metadata['tracknumber'] = "%02d" % (int(metadata['tracknumber']))
|
|
base = "%s/%s - %s" % (base, metadata['tracknumber'], metadata['title'])
|
|
else:
|
|
base = "%s/%s" % (base, metadata['title'])
|
|
else:
|
|
base = "%s/%s" % (base, original_name)
|
|
else:
|
|
base = "%s/%s" % (storage_directory, original_name)
|
|
|
|
base = "%s%s" % (base, file_ext)
|
|
|
|
filepath = self.create_unique_filename(base)
|
|
self.ensure_dir(filepath)
|
|
shutil.move(imported_filepath, filepath)
|
|
|
|
def update_airtime(self, event):
|
|
self.logger.info("Updating Change to Airtime")
|
|
try:
|
|
md5 = self.get_md5(event.pathname)
|
|
md = {'filepath':event.pathname, 'md5':md5}
|
|
|
|
file_info = mutagen.File(event.pathname, easy=True)
|
|
attrs = self.mutagen2airtime
|
|
for key in file_info.keys() :
|
|
if key in attrs :
|
|
md[attrs[key]] = file_info[key][0]
|
|
|
|
data = {'md': md}
|
|
response = self.api_client.update_media_metadata(data)
|
|
|
|
except Exception, e:
|
|
self.logger.info("%s", e)
|
|
|
|
def is_renamed_file(self, filename):
|
|
if filename in self.imported_renamed_files:
|
|
del self.imported_renamed_files[filename]
|
|
return True
|
|
|
|
return False
|
|
|
|
def is_temp_file(self, filename):
|
|
info = filename.split(".")
|
|
|
|
if(info[-2] in self.supported_file_formats):
|
|
return True
|
|
else :
|
|
return False
|
|
|
|
def is_audio_file(self, filename):
|
|
info = filename.split(".")
|
|
|
|
if(info[-1] in self.supported_file_formats):
|
|
return True
|
|
else :
|
|
return False
|
|
|
|
|
|
def process_IN_CREATE(self, event):
|
|
if not event.dir:
|
|
|
|
#file created is a tmp file which will be modified and then moved back to the original filename.
|
|
if self.is_temp_file(event.name) :
|
|
self.temp_files[event.pathname] = None
|
|
#This is a newly imported file.
|
|
else :
|
|
#if not is_renamed_file(event.pathname):
|
|
self.create_file_path(event.pathname)
|
|
|
|
self.logger.info("%s: %s", event.maskname, event.pathname)
|
|
|
|
def process_IN_MODIFY(self, event):
|
|
if not event.dir :
|
|
|
|
if self.is_audio_file(event.name) :
|
|
self.update_airtime(event)
|
|
|
|
self.logger.info("%s: %s", event.maskname, event.pathname)
|
|
|
|
def process_IN_MOVED_FROM(self, event):
|
|
if event.pathname in self.temp_files :
|
|
del self.temp_files[event.pathname]
|
|
self.temp_files[event.cookie] = event.pathname
|
|
|
|
self.logger.info("%s: %s", event.maskname, event.pathname)
|
|
|
|
def process_IN_MOVED_TO(self, event):
|
|
if event.cookie in self.temp_files :
|
|
del self.temp_files[event.cookie]
|
|
self.update_airtime(event)
|
|
|
|
self.logger.info("%s: %s", event.maskname, event.pathname)
|
|
|
|
def process_default(self, event):
|
|
self.logger.info("%s: %s", event.maskname, event.pathname)
|
|
|
|
if __name__ == '__main__':
|
|
|
|
try:
|
|
# watched events
|
|
mask = pyinotify.IN_CREATE | pyinotify.IN_MODIFY | pyinotify.IN_MOVED_FROM | pyinotify.IN_MOVED_TO
|
|
#mask = pyinotify.ALL_EVENTS
|
|
|
|
wm = WatchManager()
|
|
wdd = wm.add_watch(storage_directory, mask, rec=True, auto_add=True)
|
|
|
|
logger = logging.getLogger('root')
|
|
logger.info("Added watch to %s", storage_directory)
|
|
|
|
notifier = AirtimeNotifier(wm, MediaMonitor(), read_freq=int(config["check_filesystem_events"]), timeout=1)
|
|
notifier.coalesce_events()
|
|
notifier.loop(callback=checkRabbitMQ)
|
|
except KeyboardInterrupt:
|
|
notifier.stop()
|