def download_torrent_group(request, group_id):
if not request.user.has_perm('home.add_whattorrent'):
return {
'success': False,
'error': 'You don\'t have permission to add torrents. Talk to the administrator.',
}
try:
torrent_group = WhatTorrentGroup.objects.get(id=group_id)
except WhatTorrentGroup.DoesNotExist:
torrent_group = WhatTorrentGroup.update_from_what(get_what_client(request), group_id)
if torrent_group.torrents_json is None:
torrent_group = WhatTorrentGroup.update_from_what(get_what_client(request), group_id)
ids = get_ids_to_download(torrent_group)
try:
instance = ReplicaSet.get_what_master().get_preferred_instance()
download_location = DownloadLocation.get_what_preferred()
for torrent_id in ids:
add_torrent(request, instance, download_location, torrent_id)
except Exception as ex:
return {
'success': False,
'error': unicode(ex),
'traceback': traceback.format_exc(),
}
return {
'success': True,
'added': len(ids),
}
def add_artist(request, artist_name):
what_client = get_what_client(request)
response = what_client.request('artist', artistname=artist_name)['response']
added = 0
for group in response['torrentgroup']:
if filter_group(response['name'], group):
artist = html_unescape(response['name'])
title = html_unescape(group['groupName'])
release_type = group['releaseType']
for torrent in group['torrent']:
id = torrent['id']
priority = filter_torrent(group, torrent)
if priority and not is_existing(id):
format = torrent['format']
encoding = torrent['encoding']
torrent_size = torrent['size']
queue_item = QueueItem(
what_id=id,
priority=priority,
artist=artist,
title=title,
release_type=release_type,
format=format,
encoding=encoding,
torrent_size=torrent_size
)
queue_item.save()
added += 1
return {
'success': True,
'added': added
}
def top10_torrent_groups(request):
count = request.GET.get('count', 10)
what_client = get_what_client(request)
top10 = what_client.request('top10', limit=100)['response']
group_set = set()
results = []
for torrent in top10[0]['results']:
if torrent['groupId'] in group_set:
continue
if torrent['groupCategory'] != 1:
continue
group_set.add(torrent['groupId'])
results.append({
'id': torrent['groupId'],
'joined_artists': html_unescape(torrent['artist']),
'name': html_unescape(torrent['groupName']),
'year': torrent['groupYear'],
'wiki_image': get_image_cache_url(torrent['wikiImage']),
})
if len(results) == count:
break
torrents_have = get_torrent_groups_have(t['id'] for t in results)
for result in results:
result.update(torrents_have[result['id']])
return results
def handle(self, *args, **options):
what = get_what_client(lambda: None, True)
with open('what_manager2_torrents.jsonl', 'rb') as torrents_input:
for line in torrents_input:
data = ujson.loads(line)
info = ujson.loads(data['what_torrent']['info'])
what_torrent_id = info['torrent']['id']
what_group_id = info['group']['id']
try:
TorrentGroupMapping.objects.get(what_group_id=what_group_id)
continue
except TorrentGroupMapping.DoesNotExist:
pass
try:
migration_status = WhatTorrentMigrationStatus.objects.get(
what_torrent_id=what_torrent_id)
except WhatTorrentMigrationStatus.DoesNotExist:
continue
if migration_status.status != WhatTorrentMigrationStatus.STATUS_COMPLETE:
continue
pth_torrent_id = migration_status.pth_torrent_id
if not pth_torrent_id:
continue
try:
pth_torrent = what.request('torrent', id=pth_torrent_id)['response']
except BadIdException:
continue
pth_group_id = pth_torrent['group']['id']
print 'Saving {} mapping to {}'.format(what_group_id, pth_group_id)
TorrentGroupMapping.objects.create(
what_group_id=what_group_id,
pth_group_id=pth_group_id,
)
def update_freeleech(request):
start_time = time.time()
added = 0
total_bytes = 0
total_torrents = 0
try:
master = ReplicaSet.get_what_master()
what_client = get_what_client(request)
for what_id, what_group, what_torrent in what_client.get_free_torrent_ids():
total_bytes += what_torrent['size']
total_torrents += 1
if not WhatTorrent.is_downloaded(request, what_id=what_id):
freeleech_add_torrent(request, master, what_id)
added += 1
log_type = u'action' if added > 0 else u'info'
if added >= FREELEECH_EMAIL_THRESHOLD and socket.gethostname() == FREELEECH_HOSTNAME:
send_freeleech_email(u'Added {0} freeleech torrents'.format(added))
time_taken = time.time() - start_time
LogEntry.add(request.user, log_type,
u'Successfully updated freeleech in {0:.3f}s. '
u'{1} added. {2} / {3} torrents total.'.format(
time_taken, added, filesizeformat(total_bytes), total_torrents))
except Exception as ex:
tb = traceback.format_exc()
LogEntry.add(request.user, u'error',
u'Error updating freeleech: {0}({1})'.format(type(ex).__name__, unicode(ex)),
tb)
return {
'success': True,
'added': added
}
def sync_profile(request):
user_id = settings.WHAT_USER_ID
interval = settings.WHAT_PROFILE_SNAPSHOT_INTERVAL
snapshots = WhatUserSnapshot.objects.order_by('-datetime')[:1]
if len(snapshots) == 0 or (timezone.now() - snapshots[0].datetime).total_seconds() >= interval - 30:
what = get_what_client(request)
WhatUserSnapshot.get(what, user_id).save()
def upload_to_what(request, book_upload):
book_upload.full_clean()
if not book_upload.what_torrent_file:
raise Exception('what_torrent is no')
if not book_upload.cover_url:
raise Exception('cover_url is no')
print 'Sending request for upload to what.cd'
what = get_what_client(request)
payload_files = dict()
payload_files['file_input'] = ('torrent.torrent',
book_upload.what_torrent_file)
payload = dict()
payload['submit'] = 'true'
payload['auth'] = what.authkey
payload['type'] = '2'
payload['title'] = book_upload.author + ' - ' + book_upload.title
payload['tags'] = get_what_tags(book_upload)
payload['image'] = book_upload.cover_url
payload['desc'] = get_what_desc(book_upload)
old_content_type = what.session.headers['Content-type']
upload_exception = None
try:
del what.session.headers['Content-type']
response = what.session.post(WHAT_UPLOAD_URL,
data=payload,
files=payload_files)
if response.url == WHAT_UPLOAD_URL:
try:
errors = extract_upload_errors(response.text)
except Exception:
errors = ''
exception = Exception(
'Error uploading data to what.cd. Errors: {0}'.format(
'; '.join(errors)))
exception.response_text = response.text
raise exception
except Exception as ex:
upload_exception = ex
finally:
what.session.headers['Content-type'] = old_content_type
try:
new_torrent = safe_retrieve_new_torrent(
what, get_info_hash_from_data(book_upload.what_torrent_file))
book_upload.what_torrent = WhatTorrent.get_or_create(
request, what_id=new_torrent['torrent']['id'])
book_upload.save()
except Exception as ex:
if upload_exception:
raise upload_exception
raise ex
move_to_dest_add(request, book_upload)
return book_upload.what_torrent
def what_proxy(request):
get = dict(request.GET.lists())
action = get['action']
del get['action']
if 'auth' in get:
del get['auth']
what = get_what_client(request)
response = what.request(action, **get)
return response
def what_proxy(request):
get = dict(request.GET.lists())
action = get["action"]
del get["action"]
if "auth" in get:
del get["auth"]
what = get_what_client(request)
response = what.request(action, **get)
return response
def what_proxy(request):
get = dict(request.GET.lists())
action = get['action']
del get['action']
if 'auth' in get:
del get['auth']
what = get_what_client(request)
response = what.request(action, **get)
return response
def handle(self, *args, **options):
what_client = get_what_client(lambda: None)
while True:
response = what_json.utils.refresh_whattorrent(what_client)
print response
if response['success']:
time.sleep(5)
else:
time.sleep(15)
def get_artist(request, artist_id):
try:
if 'HTTP_X_REFRESH' in request.META:
raise WhatArtist.DoesNotExist()
artist = WhatArtist.objects.get(id=artist_id)
if artist.is_shell:
raise WhatArtist.DoesNotExist()
except WhatArtist.DoesNotExist:
artist = WhatArtist.update_from_what(get_what_client(request), artist_id)
return get_artist_dict(artist, True)
def handle(self, *args, **options):
print 'Initiating what client...'
what = get_what_client(dummy_request, True)
index_response = what.request('index')
print 'Status:', index_response['status']
print 'Scanning replica sets...'
try:
ReplicaSet.objects.get(zone='what.cd')
raise Exception('Please delete your what.cd replica set now')
except ReplicaSet.DoesNotExist:
pass
try:
pth_replica_set = ReplicaSet.get_what_master()
if pth_replica_set.transinstance_set.count() < 1:
raise ReplicaSet.DoesNotExist()
except ReplicaSet.DoesNotExist:
raise Exception('Please get your PTH replica set ready')
print 'Scanning locations...'
location_mapping = {}
with open('what_manager2_torrents.jsonl', 'rb') as torrents_input:
for line in torrents_input:
data = ujson.loads(line)
location_path = data['location']['path']
if location_path not in location_mapping:
try:
new_location = DownloadLocationEquivalent.objects.get(
old_location=location_path).new_location
except DownloadLocationEquivalent.DoesNotExist:
new_location = raw_input(
'Enter the new location to map to {}: '.format(
location_path))
DownloadLocationEquivalent.objects.create(
old_location=location_path,
new_location=new_location,
)
location_mapping[location_path] = new_location
print 'Location mappings:'
for old_location, new_location in location_mapping.items():
try:
DownloadLocation.objects.get(zone='redacted.ch',
path=new_location)
except DownloadLocation.DoesNotExist:
raise Exception(
'Please create the {} location in the DB in zone redacted.ch'
.format(new_location))
print old_location, '=', new_location
with open('what_manager2_torrents.jsonl', 'rb') as torrents_input:
for line in torrents_input:
data = ujson.loads(line)
migration_job = TorrentMigrationJob(
what,
location_mapping,
data,
flac_only=options['flac_only'])
migration_job.process()
def edit_upload_whatcd(request, upload):
if request.method == 'POST':
what_client = get_what_client(request)
temp_dir = get_temp_dir(upload.upload.metadata.id)
if request.GET['type'] == 'existing':
group_id = request.POST['group_id']
assert group_id
if 'subgroup' in request.POST:
upload.upload.upload_to_what(what_client, temp_dir, 'upload_in_subgroup',
[group_id, None])
elif 'original' in request.POST:
upload.upload.upload_to_what(what_client, temp_dir, 'upload_in_original_release',
[group_id])
elif 'with_torrent' in request.POST:
with_id = request.POST['with_id']
assert with_id
upload.upload.upload_to_what(
what_client, temp_dir, 'upload_in_subgroup', [group_id, with_id])
else:
raise Exception('Unknown button clicked')
elif request.GET['type'] == 'new':
release_type_id = request.POST['release_type']
release_tags = request.POST['tags']
assert release_type_id
assert release_tags
qiller = upload.upload
def do_upload():
kwargs = dict()
if 'force_artists' in request.POST:
kwargs['force_artists'] = True
if request.POST['original_year']:
kwargs['remaster'] = True
kwargs['original_year'] = request.POST['original_year']
qiller.upload_to_what(
what_client, temp_dir, 'upload_new_group',
[release_type_id, release_tags], kwargs
)
upload.set_upload(qiller)
upload.save()
try:
do_upload()
except MissingImageException:
do_upload_cover(upload, temp_dir, qiller)
do_upload()
else:
raise Exception('Unknown type')
return redirect(seed_upload, upload.id)
data = {
'upload': upload,
'spectrals': get_spectral_files(upload.upload),
'release_types': WHAT_RELEASE_TYPES,
}
return render(request, 'qobuz2/upload_whatcd.html', data)
def get_torrent_group(request, group_id):
try:
if 'HTTP_X_REFRESH' in request.META:
raise WhatTorrentGroup.DoesNotExist()
torrent_group = WhatTorrentGroup.objects.get(id=group_id)
except WhatTorrentGroup.DoesNotExist:
what_client = get_what_client(request)
torrent_group = WhatTorrentGroup.update_from_what(what_client, group_id)
data = get_torrent_group_dict(torrent_group)
data.update(get_torrent_groups_have([torrent_group.id], True)[torrent_group.id])
return data
def sync_profile(request):
user_id = settings.WHAT_USER_ID
interval = settings.WHAT_PROFILE_SNAPSHOT_INTERVAL
try:
last_snap = WhatUserSnapshot.get_last()
if (timezone.now() - last_snap.datetime).total_seconds() < interval - 30:
return
except WhatUserSnapshot.DoesNotExist:
pass
what = get_what_client(request)
WhatUserSnapshot.get(what, user_id).save()
def sync_profile(request):
user_id = settings.WHAT_USER_ID
interval = settings.WHAT_PROFILE_SNAPSHOT_INTERVAL
try:
last_snap = WhatUserSnapshot.get_last()
if (timezone.now() -
last_snap.datetime).total_seconds() < interval - 30:
return
except WhatUserSnapshot.DoesNotExist:
pass
what = get_what_client(request)
WhatUserSnapshot.get(what, user_id).save()
def update_freeleech(request):
start_time = time.time()
added = 0
total_bytes = 0
total_torrents = 0
try:
master = ReplicaSet.get_what_master()
what_client = get_what_client(request)
for what_id, what_group, what_torrent in what_client.get_free_torrent_ids():
total_bytes += what_torrent['size']
total_torrents += 1
if not WhatTorrent.is_downloaded(request, what_id=what_id):
download_locations = DownloadLocation.objects.filter(zone=ReplicaSet.ZONE_WHAT)
download_locations = [l for l in download_locations if l.free_space_percent >= MIN_FREE_DISK_SPACE]
if len(download_locations) == 0:
LogEntry.add(request.user, u'error',
u'Unable to update freeleech: not enough space on disk.')
return {
'success': False,
'error': u'Not enough free space on disk.'
}
download_location = choice(download_locations)
instance = master.get_preferred_instance()
m_torrent = manage_torrent.add_torrent(request, instance, download_location, what_id, True)
m_torrent.what_torrent.tags = 'seed'
m_torrent.what_torrent.added_by = request.user
m_torrent.what_torrent.save()
added += 1
LogEntry.add(request.user, u'action',
u'Added freeleech {0} to {1} - {2}'.format(m_torrent, m_torrent.instance,
download_location.path))
log_type = u'action' if added > 0 else u'info'
if added >= FREELEECH_EMAIL_THRESHOLD and socket.gethostname() == FREELEECH_HOSTNAME:
send_freeleech_email(u'Added {0} freeleech torrents'.format(added))
time_taken = time.time() - start_time
LogEntry.add(request.user, log_type,
u'Successfully updated freeleech in {0:.3f}s. {1} added. {2} / {3} torrents total.'.format(
time_taken, added, filesizeformat(total_bytes), total_torrents))
except Exception as ex:
tb = traceback.format_exc()
LogEntry.add(request.user, u'error',
u'Error updating freeleech: {0}({1})'.format(type(ex).__name__, unicode(ex)), tb)
return {
'success': True,
'added': added
}
def handle(self, *args, **options):
print 'Initiating what client...'
what = get_what_client(dummy_request, True)
index_response = what.request('index')
print 'Status:', index_response['status']
print 'Scanning replica sets...'
try:
ReplicaSet.objects.get(zone='what.cd')
raise Exception('Please delete your what.cd replica set now')
except ReplicaSet.DoesNotExist:
pass
try:
pth_replica_set = ReplicaSet.get_what_master()
if pth_replica_set.transinstance_set.count() < 1:
raise ReplicaSet.DoesNotExist()
except ReplicaSet.DoesNotExist:
raise Exception('Please get your PTH replica set ready')
print 'Scanning locations...'
location_mapping = {}
with open('what_manager2_torrents.jsonl', 'rb') as torrents_input:
for line in torrents_input:
data = ujson.loads(line)
location_path = data['location']['path']
if location_path not in location_mapping:
try:
new_location = DownloadLocationEquivalent.objects.get(
old_location=location_path).new_location
except DownloadLocationEquivalent.DoesNotExist:
new_location = raw_input(
'Enter the new location to map to {}: '.format(location_path))
DownloadLocationEquivalent.objects.create(
old_location=location_path,
new_location=new_location,
)
location_mapping[location_path] = new_location
print 'Location mappings:'
for old_location, new_location in location_mapping.items():
try:
DownloadLocation.objects.get(zone='redacted.ch', path=new_location)
except DownloadLocation.DoesNotExist:
raise Exception(
'Please create the {} location in the DB in zone redacted.ch'.format(
new_location))
print old_location, '=', new_location
with open('what_manager2_torrents.jsonl', 'rb') as torrents_input:
for line in torrents_input:
data = ujson.loads(line)
migration_job = TorrentMigrationJob(what, location_mapping, data,
flac_only=options['flac_only'])
migration_job.process()
def handle(self, *args, **options):
if len(args) != 1:
print u'Pass only the source directory.'
return 1
source_dir = wm_unicode(args[0])
if source_dir.endswith('/'):
source_dir = source_dir[:-1]
what = get_what_client(lambda: None)
job = TranscodeSingleJob(what, None, report_progress, None, None, source_dir)
job.create_torrent()
raw_input('Please upload the torrent and press enter...')
job.move_torrent_to_dest()
add_to_wm_transcode(job.new_torrent['torrent']['id'])
def handle(self, *args, **options):
if len(args) != 1:
print u'Pass only the source directory.'
return 1
source_dir = wm_unicode(args[0])
if source_dir.endswith('/'):
source_dir = source_dir[:-1]
what = get_what_client(lambda: None)
job = TranscodeSingleJob(what, None, report_progress, None, None,
source_dir)
job.create_torrent()
raw_input('Please upload the torrent and press enter...')
job.move_torrent_to_dest()
add_to_wm_transcode(job.new_torrent['torrent']['id'])
def run(self):
temp_dir = make_temp_dir()
if os.path.exists(temp_dir):
raise Exception('Destination directory exists')
# Pass an object that can hold the what_client property
self.what = get_what_client(lambda: None)
os.makedirs(temp_dir)
try:
self.transcode_upload_lossless(temp_dir)
finally:
try:
shutil.rmtree(temp_dir)
except OSError:
pass
def run(self):
temp_dir = make_temp_dir()
if os.path.exists(temp_dir):
raise Exception('Destination directory exists')
# Pass an object that can hold the what_client property
self.what = get_what_client(lambda: None)
os.makedirs(temp_dir)
try:
self.transcode_upload_lossless(temp_dir)
finally:
try:
shutil.rmtree(temp_dir)
except OSError:
pass
def run(self):
try:
shutil.rmtree(TRANSCODER_TEMP_DIR)
except OSError:
pass
self.what = get_what_client(lambda: None) # Pass an object that can hold the what_client property
os.makedirs(TRANSCODER_TEMP_DIR)
try:
self.transcode_upload_lossless()
finally:
try:
shutil.rmtree(TRANSCODER_TEMP_DIR)
except OSError:
pass
def run(self):
try:
shutil.rmtree(TRANSCODER_TEMP_DIR)
except OSError:
pass
# Pass an object that can hold the what_client property
self.what = get_what_client(lambda: None)
os.makedirs(TRANSCODER_TEMP_DIR)
try:
self.transcode_upload_lossless()
finally:
try:
shutil.rmtree(TRANSCODER_TEMP_DIR)
except OSError:
pass
def process_request(t_r):
t_r.show_retry_button = False
if t_r.celery_task_id is None:
try:
t_torrent = get_trans_torrent(t_r.what_torrent)
t_torrent.sync_t_torrent()
if t_torrent.torrent_done == 1:
t_r.status = 'download complete. transcoding should start within 1 minute.'
else:
t_r.status = 'downloading ({0:.0%})'.format(
t_torrent.torrent_done)
downloading.append(t_r)
except TransTorrent.DoesNotExist:
t_r.status = 'torrent has been removed'
failed.append(t_r)
elif t_r.date_completed is not None:
t_r.status = 'completed {0} ago'.format(
timesince_filter(t_r.date_completed))
succeeded.append(t_r)
else:
async_result = AsyncResult(t_r.celery_task_id)
if async_result.state == states.PENDING:
t_r.status = 'pending transcoding'
pending.append(t_r)
elif async_result.state == states.STARTED:
t_r.status = 'transcoding'
transcoding.append(t_r)
elif async_result.state == 'PROGRESS':
t_r.status = 'transcoding: {0}'.format(
async_result.info['status_message'])
transcoding.append(t_r)
elif async_result.state == states.SUCCESS:
t_r.status = 'completed'
succeeded.append(t_r)
elif async_result.state == states.FAILURE:
t_r.show_retry_button = allow_retry
t_r.status = 'failed - {0}({1})'.format(
type(async_result.result).__name__,
async_result.result.message)
failed.append(t_r)
what_client = get_what_client(request)
t_r.status = t_r.status.replace(what_client.authkey,
'<authkey>').replace(
what_client.passkey, '<passkey>')
def refresh_whattorrent(request):
if 'id' in request.GET:
most_recent = WhatTorrent.objects.get(id=request.GET['id'])
else:
most_recent = WhatTorrent.objects.defer('torrent_file').order_by('retrieved')[0]
most_recent_id = most_recent.id
what = get_what_client(request)
try:
response = what.request('torrent', id=most_recent.id)['response']
except RequestException as ex:
if ex.response and type(ex.response) is dict and ex.response.get('error') == 'bad id parameter':
try:
TransTorrent.objects.get(instance__in=ReplicaSet.get_what_master().transinstance_set.all(),
what_torrent=most_recent)
return {
'success': False,
'id': most_recent_id,
'status': 'missing',
}
except TransTorrent.DoesNotExist:
most_recent.delete()
return {
'success': True,
'id': most_recent_id,
'status': 'deleted',
}
else:
return {
'success': False,
'status': 'unknown request exception',
}
old_retrieved = most_recent.retrieved
most_recent.info = json.dumps(response)
most_recent.retrieved = timezone.now()
most_recent.save()
return {
'success': True,
'id': most_recent_id,
'status': 'refreshed',
'retrieved': unicode(old_retrieved),
}
def process_request(t_r):
t_r.show_retry_button = False
if t_r.celery_task_id is None:
try:
t_torrent = get_trans_torrent(t_r.what_torrent)
t_torrent.sync_t_torrent()
if t_torrent.torrent_done == 1:
t_r.status = 'download complete. transcoding should start within 1 minute.'
else:
t_r.status = 'downloading ({0:.0%})'.format(t_torrent.torrent_done)
downloading.append(t_r)
except TransTorrent.DoesNotExist:
t_r.status = 'torrent has been removed'
failed.append(t_r)
elif t_r.date_completed is not None:
t_r.status = 'completed {0} ago'.format(timesince_filter(t_r.date_completed))
succeeded.append(t_r)
else:
async_result = AsyncResult(t_r.celery_task_id)
if async_result.state == states.PENDING:
t_r.status = 'pending transcoding'
pending.append(t_r)
elif async_result.state == states.STARTED:
t_r.status = 'transcoding'
transcoding.append(t_r)
elif async_result.state == 'PROGRESS':
t_r.status = 'transcoding: {0}'.format(async_result.info['status_message'])
transcoding.append(t_r)
elif async_result.state == states.SUCCESS:
t_r.status = 'completed'
succeeded.append(t_r)
elif async_result.state == states.FAILURE:
t_r.show_retry_button = allow_retry
t_r.status = 'failed - {0}({1})'.format(type(async_result.result).__name__,
async_result.result.message)
failed.append(t_r)
what_client = get_what_client(request)
t_r.status = t_r.status.replace(what_client.authkey, '<authkey>').replace(
what_client.passkey, '<passkey>')
def add_collage(request, collage_id):
what_client = get_what_client(request)
response = what_client.request('collage', id=collage_id)['response']
added = 0
torrent_group_count = 0
torrent_count = 0
for group in response['torrentgroups']:
if group['categoryId'] not in [1, '1']:
continue
artist = get_artists(group)
title = html_unescape(group['name'])
release_type = group['releaseType']
for torrent in group['torrents']:
what_id = torrent['torrentid']
priority = filter_torrent(group, torrent)
if priority and not is_existing(what_id):
torrent_format = torrent['format']
encoding = torrent['encoding']
torrent_size = torrent['size']
queue_item = QueueItem(
what_id=what_id,
priority=priority,
artist=artist,
title=title,
release_type=release_type,
format=torrent_format,
encoding=encoding,
torrent_size=torrent_size
)
queue_item.save()
added += 1
torrent_count += 1
torrent_group_count += 1
return {
'success': True,
'added': added,
'groups': torrent_group_count,
'torrents': torrent_count
}
def update_freeleech(request):
start_time = time.time()
added = 0
total_bytes = 0
total_torrents = 0
try:
master = ReplicaSet.get_what_master()
what_client = get_what_client(request)
for what_id, what_group, what_torrent in what_client.get_free_torrent_ids():
total_bytes += what_torrent["size"]
total_torrents += 1
if not WhatTorrent.is_downloaded(request, what_id=what_id):
freeleech_add_torrent(request, master, what_id)
added += 1
log_type = u"action" if added > 0 else u"info"
if added >= FREELEECH_EMAIL_THRESHOLD and socket.gethostname() == FREELEECH_HOSTNAME:
send_freeleech_email(u"Added {0} freeleech torrents".format(added))
time_taken = time.time() - start_time
LogEntry.add(
request.user,
log_type,
u"Successfully updated freeleech in {0:.3f}s. "
u"{1} added. {2} / {3} torrents total.".format(
time_taken, added, filesizeformat(total_bytes), total_torrents
),
)
except Exception as ex:
tb = traceback.format_exc()
LogEntry.add(
request.user, u"error", u"Error updating freeleech: {0}({1})".format(type(ex).__name__, unicode(ex)), tb
)
return {"success": True, "added": added}
def request_transcode(request):
try:
request_what_user = request_get_what_user(request)
except Exception:
return {
'message': 'You don\'t have permission to add transcode requests.'
}
try:
what_id = int(request.POST['what_id'])
except:
return {
'message': 'Missing or invalid what id'
}
try:
try:
TranscodeRequest.objects.get(what_torrent_id=what_id)
return {
'message': 'This has already been requested.'
}
except TranscodeRequest.DoesNotExist:
pass
what_client = get_what_client(request)
what_torrent = WhatTorrent.get_or_create(request, what_id=what_id)
if what_torrent.info_loads['torrent']['format'] != 'FLAC':
return {
'message': 'This is not a FLAC torrent. Only FLACs can be transcoded.'
}
if what_torrent.info_loads['torrent']['reported']:
return {
'message': 'You cannot add a request for a torrent that has been reported.'
}
if what_torrent.info_loads['torrent']['scene']:
return {
'message': 'Cannot transcode a scene torrent due to possible release group name in the file names.'
}
if torrent_is_preemphasized(what_torrent.info_loads):
return {
'message': 'This sounds as if it is pre-emphasized. Will not add request.'
}
group = what_client.request('torrentgroup', id=what_torrent.info_loads['group']['id'])['response']
mp3_ids = get_mp3_ids(group, what_torrent.info_loads)
if '320' in mp3_ids and 'V0' in mp3_ids:
return {
'message': 'This torrent already has both a V0 and a 320.'
}
transcode_request = TranscodeRequest(
what_torrent=what_torrent,
requested_by_ip=request.META['REMOTE_ADDR'],
requested_by_what_user=request_what_user,
)
transcode_request.save()
try:
get_trans_torrent(what_torrent)
except TransTorrent.DoesNotExist:
instance = ReplicaSet.get_what_master().get_preferred_instance()
download_location = DownloadLocation.get_what_preferred()
m_torrent = add_torrent(request, instance, download_location, what_id)
if request.user.is_authenticated():
m_torrent.what_torrent.added_by = request.user
else:
m_torrent.what_torrent.added_by = None
m_torrent.what_torrent.tags = 'transcode'
m_torrent.what_torrent.save()
if request.user.is_authenticated():
log_user = request.user
else:
log_user = None
LogEntry.add(log_user, u'action', u'Transcode What.CD user {0} added {1} to {2}'.format(request_what_user, m_torrent, m_torrent.instance))
return {
'message': 'Request added.',
}
except Exception as ex:
tb = traceback.format_exc()
if request.user.is_authenticated():
current_user = request.user
else:
current_user = None
LogEntry.add(current_user, u'error', u'What user {0} tried adding what_id {1}. Error: {2}'.format(request_what_user, what_id, ex), tb)
return {
'message': 'Error adding request: ' + str(ex)
}
def run_request_transcode(request, what_id):
try:
request_what_user = request_get_what_user(request)
except Exception:
return {
'message': 'You don\'t have permission to add transcode requests.'
}
try:
what_id = int(what_id)
except:
return {'message': 'Missing or invalid what id'}
try:
try:
TranscodeRequest.objects.get(what_torrent_id=what_id)
return {'message': 'This has already been requested.'}
except TranscodeRequest.DoesNotExist:
pass
what_client = get_what_client(request)
what_torrent = WhatTorrent.get_or_create(request, what_id=what_id)
if what_torrent.info_loads['torrent']['format'] != 'FLAC':
return {
'message':
'This is not a FLAC torrent. Only FLACs can be transcoded.'
}
if what_torrent.info_loads['torrent']['reported']:
return {
'message':
'You cannot add a request for a torrent that has been reported.'
}
if what_torrent.info_loads['torrent']['scene']:
return {
'message':
'Cannot transcode a scene torrent due to possible'
' release group name in the file names.'
}
if torrent_is_preemphasized(what_torrent.info_loads):
return {
'message':
'This sounds as if it is pre-emphasized. Will not add request.'
}
group = what_client.request(
'torrentgroup',
id=what_torrent.info_loads['group']['id'])['response']
mp3_ids = get_mp3_ids(group, what_torrent.info_loads)
if all(f in mp3_ids for f in TRANSCODER_FORMATS):
return {
'message':
'This torrent already has all the formats: {0}.'.format(
', '.join(TRANSCODER_FORMATS))
}
transcode_request = TranscodeRequest(
what_torrent=what_torrent,
requested_by_ip=request.META['REMOTE_ADDR'],
requested_by_what_user=request_what_user,
)
transcode_request.save()
try:
get_trans_torrent(what_torrent)
except TransTorrent.DoesNotExist:
instance = ReplicaSet.get_what_master().get_preferred_instance()
download_location = DownloadLocation.get_what_preferred()
m_torrent = add_torrent(request, instance, download_location,
what_id)
if request.user.is_authenticated():
m_torrent.what_torrent.added_by = request.user
else:
m_torrent.what_torrent.added_by = None
m_torrent.what_torrent.tags = 'transcode'
m_torrent.what_torrent.save()
if request.user.is_authenticated():
log_user = request.user
else:
log_user = None
LogEntry.add(
log_user, u'action',
u'Transcode What.CD user {0} added {1} to {2}'.format(
request_what_user, m_torrent, m_torrent.instance))
return {
'message': 'Request added.',
}
except Exception as ex:
tb = traceback.format_exc()
if request.user.is_authenticated():
current_user = request.user
else:
current_user = None
LogEntry.add(
current_user, u'error',
u'What user {0} tried adding what_id {1}. Error: {2}'.format(
request_what_user, what_id, ex), tb)
return {'message': 'Error adding request: ' + str(ex)}
def refresh_whattorrent(request):
what_torrent = None
if 'id' in request.GET:
what_torrent = WhatTorrent.objects.get(id=request.GET['id'])
what_client = get_what_client(request)
return utils.refresh_whattorrent(what_client, what_torrent)
def refresh_whattorrent(request):
what_torrent = None
if "id" in request.GET:
what_torrent = WhatTorrent.objects.get(id=request.GET["id"])
what_client = get_what_client(request)
return utils.refresh_whattorrent(what_client, what_torrent)
