266 lines
10 KiB
Python
266 lines
10 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
|
|
#
|
|
# Basic plugin template created by:
|
|
# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
|
|
# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
|
|
#
|
|
# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with
|
|
# the additional special exception to link portions of this program with the OpenSSL library.
|
|
# See LICENSE for more details.
|
|
#
|
|
|
|
from __future__ import unicode_literals
|
|
|
|
import errno
|
|
import logging
|
|
import os
|
|
|
|
from twisted.internet.utils import getProcessOutputAndValue
|
|
from twisted.python.procutils import which
|
|
|
|
import deluge.component as component
|
|
import deluge.configmanager
|
|
from deluge.configmanager import ConfigManager
|
|
from deluge.common import windows_check
|
|
from deluge.core.rpcserver import export
|
|
from deluge.plugins.pluginbase import CorePluginBase
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
DEFAULT_PREFS = {'extract_path': '',
|
|
'extract_in_place': False,
|
|
'extract_selected_folder': False,
|
|
'extract_torrent_root': True,
|
|
'label_filter': ''}
|
|
|
|
if windows_check():
|
|
win_7z_exes = [
|
|
'7z.exe',
|
|
'C:\\Program Files\\7-Zip\\7z.exe',
|
|
'C:\\Program Files (x86)\\7-Zip\\7z.exe',
|
|
]
|
|
|
|
switch_7z = 'x -y'
|
|
# Future suport:
|
|
# 7-zip cannot extract tar.* with single command.
|
|
# ".tar.gz", ".tgz",
|
|
# ".tar.bz2", ".tbz",
|
|
# ".tar.lzma", ".tlz",
|
|
# ".tar.xz", ".txz",
|
|
exts_7z = ['.rar', '.zip', '.tar', '.7z', '.xz', '.lzma']
|
|
for win_7z_exe in win_7z_exes:
|
|
if which(win_7z_exe):
|
|
EXTRACT_COMMANDS = dict.fromkeys(exts_7z, [win_7z_exe, switch_7z])
|
|
break
|
|
else:
|
|
required_cmds = ['unrar', 'unzip', 'tar', 'unxz', 'unlzma', '7zr', 'bunzip2']
|
|
# Possible future suport:
|
|
# gunzip: gz (cmd will delete original archive)
|
|
# the following do not extract to dest dir
|
|
# ".xz": ["xz", "-d --keep"],
|
|
# ".lzma": ["xz", "-d --format=lzma --keep"],
|
|
# ".bz2": ["bzip2", "-d --keep"],
|
|
|
|
EXTRACT_COMMANDS = {
|
|
'.rar': ['unrar', 'x -o+ -y'],
|
|
'.tar': ['tar', '-xf'],
|
|
'.zip': ['unzip', ''],
|
|
'.tar.gz': ['tar', '-xzf'],
|
|
'.tgz': ['tar', '-xzf'],
|
|
'.tar.bz2': ['tar', '-xjf'],
|
|
'.tbz': ['tar', '-xjf'],
|
|
'.tar.lzma': ['tar', '--lzma -xf'],
|
|
'.tlz': ['tar', '--lzma -xf'],
|
|
'.tar.xz': ['tar', '--xz -xf'],
|
|
'.txz': ['tar', '--xz -xf'],
|
|
'.7z': ['7zr', 'x'],
|
|
}
|
|
# Test command exists and if not, remove.
|
|
for command in required_cmds:
|
|
if not which(command):
|
|
for k, v in list(EXTRACT_COMMANDS.items()):
|
|
if command in v[0]:
|
|
log.warning('%s not found, disabling support for %s', command, k)
|
|
del EXTRACT_COMMANDS[k]
|
|
|
|
if not EXTRACT_COMMANDS:
|
|
raise Exception('No archive extracting programs found, plugin will be disabled')
|
|
|
|
|
|
class Core(CorePluginBase):
|
|
def enable(self):
|
|
self.config = deluge.configmanager.ConfigManager(
|
|
'simpleextractor.conf', DEFAULT_PREFS
|
|
)
|
|
if not self.config['extract_path']:
|
|
self.config['extract_path'] = deluge.configmanager.ConfigManager(
|
|
'core.conf'
|
|
)['download_location']
|
|
component.get('EventManager').register_event_handler(
|
|
'TorrentFinishedEvent', self._on_torrent_finished
|
|
)
|
|
|
|
def disable(self):
|
|
component.get('EventManager').deregister_event_handler(
|
|
'TorrentFinishedEvent', self._on_torrent_finished
|
|
)
|
|
|
|
def update(self):
|
|
pass
|
|
|
|
def _on_torrent_finished(self, torrent_id):
|
|
"""
|
|
This is called when a torrent finishes and checks if any files to extract.
|
|
"""
|
|
tid = component.get('TorrentManager').torrents[torrent_id]
|
|
tid_status = tid.get_status(['download_location', 'name'])
|
|
tstatus = tid.get_status([], False, False, True)
|
|
do_extract = False
|
|
tid = component.get("TorrentManager").torrents[torrent_id]
|
|
tid_status = tid.get_status(["save_path", "name"])
|
|
|
|
#tid.is_finished = False
|
|
log.info("Processing completed torrent %s", tstatus)
|
|
# Fetch our torrent's label
|
|
labels = self.get_labels(torrent_id)
|
|
log.info("Schmancy label collector: %s", labels)
|
|
# If we've set a label filter, process it
|
|
if self.config['label_filter'] is not "":
|
|
log.info("We should filter by label(s): %s", self.config['extract_labels'])
|
|
# Make sure there's actually a label
|
|
if len(labels) > 0:
|
|
for label in labels:
|
|
log.info("Label for torrent is %s", label)
|
|
# Check if it's more than one, split
|
|
if "," in self.config['extract_labels']:
|
|
log.info("And we have a list")
|
|
label_list = self.config['extract_labels'].split(",")
|
|
# And loop
|
|
for label in label_list:
|
|
if label.strip() == label:
|
|
log.info("This matches")
|
|
do_extract = True
|
|
break
|
|
# Otherwise, just check the whole string
|
|
else:
|
|
log.info("Single label string detected.")
|
|
if self.config['extract_labels'].strip() == label:
|
|
log.info("This matches")
|
|
do_extract = True
|
|
# We don't need to do this, but it adds sanity
|
|
else:
|
|
log.info("We have a label filter and no label, doing nothing")
|
|
do_extract = False
|
|
# Otherwise, we just extract everything
|
|
else:
|
|
log.info("No label, extracting.")
|
|
do_extract = True
|
|
|
|
# Now, extract if filter match or no filter set
|
|
extract_in_place = self.config["extract_in_place"]
|
|
extract_torrent_root = self.config["extract_torrent_root"]
|
|
|
|
if do_extract:
|
|
files = tid.get_files()
|
|
for f in files:
|
|
log.info("Handling file %s", f['path'])
|
|
file_root, file_ext = os.path.splitext(f['path'])
|
|
file_ext_sec = os.path.splitext(file_root)[1]
|
|
if file_ext_sec and file_ext_sec + file_ext in EXTRACT_COMMANDS:
|
|
file_ext = file_ext_sec + file_ext
|
|
elif file_ext not in EXTRACT_COMMANDS or file_ext_sec == '.tar':
|
|
log.info('Cannot extract file with unknown file type: %s', f['path'])
|
|
continue
|
|
elif file_ext == '.rar' and 'part' in file_ext_sec:
|
|
part_num = file_ext_sec.split('part')[1]
|
|
if part_num.isdigit() and int(part_num) != 1:
|
|
log.info('Skipping remaining multi-part rar files: %s', f['path'])
|
|
continue
|
|
|
|
cmd = EXTRACT_COMMANDS[file_ext]
|
|
|
|
fpath = os.path.join(
|
|
tid_status['download_location'], os.path.normpath(f['path'])
|
|
)
|
|
|
|
# Get the destination path
|
|
dest = os.path.normpath(self.config["extract_path"])
|
|
name_dest = os.path.join(dest, tid_status["name"])
|
|
|
|
# Override destination if in_place_extraction is set
|
|
if extract_torrent_root:
|
|
dest = tid_status["save_path"]
|
|
name_dest = os.path.join(dest, tid_status["name"])
|
|
|
|
if extract_in_place and ((not os.path.exists(name_dest)) or os.path.isdir(name_dest)):
|
|
dest = name_dest
|
|
|
|
try:
|
|
os.makedirs(dest)
|
|
except OSError as ex:
|
|
if not (ex.errno == errno.EEXIST and os.path.isdir(dest)):
|
|
log.error("EXTRACTOR: Error creating destination folder: %s", ex)
|
|
break
|
|
|
|
def on_extract(result, torrent_id, fpath):
|
|
# Check command exit code.
|
|
if not result[2]:
|
|
log.info('Extract successful: %s (%s)', fpath, torrent_id)
|
|
else:
|
|
log.error(
|
|
'Extract failed: %s (%s) %s', fpath, torrent_id, result[1]
|
|
)
|
|
|
|
# Run the command and add callback.
|
|
log.info(
|
|
'Extracting %s from %s with %s %s to %s',
|
|
fpath,
|
|
torrent_id,
|
|
cmd[0],
|
|
cmd[1],
|
|
dest,
|
|
)
|
|
d = getProcessOutputAndValue(
|
|
cmd[0], cmd[1].split() + [str(fpath)], os.environ, str(dest)
|
|
)
|
|
d.addCallback(on_extract, torrent_id, fpath)
|
|
#tid.is_finished = True
|
|
|
|
def get_labels(self, torrent_id):
|
|
"""
|
|
Asking the system about the labels isn't very cool, so try this instead
|
|
"""
|
|
labels = []
|
|
label_config = ConfigManager('label.conf', defaults=False)
|
|
if label_config is not False:
|
|
log.info("We have a Label config")
|
|
if 'torrent_labels' in label_config:
|
|
if torrent_id in label_config['torrent_labels']:
|
|
log.info("Data from Label plugin: %s", label_config['torrent_labels'][torrent_id])
|
|
labels.append(label_config['torrent_labels'][torrent_id])
|
|
|
|
label_plus_config = ConfigManager('labelplus.conf', defaults=False)
|
|
if label_plus_config is not False:
|
|
log.info("We have a label plus config")
|
|
if 'mappings' in label_plus_config:
|
|
if torrent_id in label_plus_config['mappings']:
|
|
mapping = label_plus_config['mappings'][torrent_id]
|
|
log.info("We have a label plus mapping: %s", mapping)
|
|
labels.append(label_plus_config['labels'][mapping]['name'])
|
|
return labels
|
|
|
|
|
|
@export
|
|
def set_config(self, config):
|
|
"""Sets the config dictionary."""
|
|
for key in config:
|
|
self.config[key] = config[key]
|
|
self.config.save()
|
|
|
|
@export
|
|
def get_config(self):
|
|
"""Returns the config dictionary."""
|
|
return self.config.config
|