def handle(self, signum, frame):
logger.error('Interrupted by signal {}'.format(signum))
for handler in reversed(self._handlers.get(signum, [])):
handler(signum, frame)
signal.signal(signum, signal.SIG_IGN)
if signum == signal.SIGINT and self.exit_on_interrupt:
sys.exit()
def shget():
urls = Config['shget'].urls
for url in urls:
try:
downloader(url).retrieve()
except InvalidURLError as e:
logger.error(e)
def move_to_dest_dir(self):
try:
shutil.move(self.move_source, self.move_dest)
if self.verbose:
logger.info('extracted archive to {}.'.format(self.move_dest))
except Exception as e:
logger.error(e)
msg = 'Moving the extracted data to \'{}\' failed.'
raise PathError(msg.format(self.move_dest.decode('utf-8')))
def request(self):
self.update()
if not self.downloaded:
response = self.client.request(self.torrent)
if response.get('status') == 'ERROR':
msg = response.get('error_message')
logger.error('Error requesting torrent: {}'.format(msg))
else:
self._create_info = response.get('transfer', {})
def _download_file(self, link, name):
downloader = Downloader(link)
try:
downloader.retrieve()
except tek.errors.NotEnoughDiskSpace as e:
logger.error(e)
else:
state = 'complete' if downloader.success else 'failed'
logger.info('')
logger.info('Download {}: {}'.format(state, name))
def launch(self):
for command in self.commands:
proc = subprocess.Popen(args=['iptables'] + command.strings,
stderr=subprocess.PIPE)
proc.wait()
err = proc.stderr.readlines()
if err:
logger.error(''.join([l.decode() for l in err]))
msg = 'Something went wrong. Most likely you are not root.'
raise TException(msg)
def main(func, handle_sigint=True, *a, **kw):
try:
if handle_sigint:
SignalManager.instance.sigint()
return func(*a, **kw)
except TException as e:
logger.error(e)
except Exception as e:
logger.error(e)
if dodebug:
raise
def create(self, section, defaults):
config = Configuration(defaults)
if self._allow_files:
try:
file_config = dict(self.config_parser.items(section))
config.set_file_config(file_config)
except configparser.NoSectionError as e:
logger.debug('configparser: ' + str(e))
except configparser.Error as e:
logger.error('configparser: ' + str(e))
return config
def _archive_type(self, path):
""" file returns a string formatted like application/x-gzip or
application/zip choose second part and remove eventual leading
'x-'
"""
try:
output = process_output(['file', '--mime-type', '-b', path])[0]
mtype = output.split('/')[-1]
if mtype.startswith('x-'):
mtype = mtype[2:]
return mtype
except MooException as e:
logger.error('Error while determining mime type: {}'.format(e))
def extract_files(files, destdir):
password = global_password()
tempdir = Config['extract'].temp
action = 'list' if Config['extract'].list else 'extract'
for _path in files:
try:
job = ExtractJob(_path,
dest_dir=destdir,
use_temp_dir=tempdir,
password=password,
action=action)
yield job.process()
except (PathError, MimeTypeError) as e:
logger.error('Error while extracting files: {}'.format(e))
def query(self, url):
data = dict(response_format='json', link=url)
response = {}
try:
request = requests.post(self._link_checker_url,
data=data,
timeout=5)
except requests.RequestException as e:
logger.error('Error querying url checker for {}: {}'.format(
url, e))
else:
if isinstance(request.json(), dict):
response = request.json()
request.connection.close()
return LinkStatus(response)
def extract(self):
""" extract the archive.
@returns: the target location
"""
self._process_password_param()
if self.use_temp_dir:
self.create_temp_dir()
self.dir_name = self.archive.extract(self.exdir, self.verbose)
self.move_dest = self.exdir
if self.use_temp_dir:
self.determine_move_dirs()
try:
self.check_destination_dir()
self.move_to_dest_dir()
except PathError as e:
logger.error('Error while extracting: {}'.format(e))
self.cleanup()
return self.move_dest
def check(self, url):
valid = True
status = LinkStatus(
dict(status='failed', result='unable to query link checker'))
if self._link_checker_url:
try:
status = self.query(url)
if not status.success:
url = resolve_redirect(url)
status = self.query(url)
except ValueError as e:
logger.error('Error checking url {}: {}'.format(url, e))
valid = True
except requests.RequestException:
raise InvalidURLError('couldn\'t connect')
else:
valid = status.success and not status.error
return valid, status
def delete(self):
for p in self._parts:
try:
os.remove(p)
except IOError as e:
logger.error(e)
