def podcast(request, podcast):
if not check_publisher_permission(request.user, podcast):
return HttpResponseForbidden()
timeline_data = listener_data([podcast])
subscription_data = subscriber_data([podcast])[-20:]
if podcast.group:
group = podcastgroup_by_id(podcast.group)
else:
group = None
update_token = request.user.publisher_update_token
heatmap = EpisodeHeatmap(podcast.get_id())
pubsubscription = subscription_for_topic(podcast.url)
site = RequestSite(request)
feedurl_quoted = urllib.quote(podcast.url)
return render(request, 'publisher/podcast.html', {
'site': site,
'podcast': podcast,
'group': group,
'form': None,
'timeline_data': timeline_data,
'subscriber_data': subscription_data,
'update_token': update_token,
'heatmap': heatmap,
'feedurl_quoted': feedurl_quoted,
'pubsubscription': pubsubscription,
})
def post(self, request):
""" Callback to notify about a feed update """
feed_url = request.GET.get('url')
if not feed_url:
logger.info('received notification without url')
return HttpResponse(status=400)
logger.info('received notification for %s' % feed_url)
subscription = subscription_for_topic(feed_url)
if subscription is None:
logger.warn('no subscription for this URL')
return HttpResponse(status=400)
if subscription.mode != 'subscribe':
logger.warn('invalid subscription mode: %s' % subscription.mode)
return HttpResponse(status=400)
if not subscription.verified:
logger.warn('the subscription has not yet been verified')
return HttpResponse(status=400)
subscription_updated.send(sender=feed_url)
return HttpResponse(status=200)
def subscribe(feedurl, huburl, base_url, mode='subscribe'):
""" Subscribe to the feed at a Hub """
logger.info('subscribing for {feed} at {hub}'.format(feed=feedurl,
hub=huburl))
verify = 'sync'
subscription = subscription_for_topic(feedurl)
if subscription is None:
subscription = Subscription()
subscription.verify_token = random_token()
if subscription.mode == mode:
if subscription.verified:
logger.info('subscription already exists')
return
else:
logger.info('subscription exists but has wrong mode: ' +
'old: %(oldmode)s, new: %(newmode)s. Overwriting.' %
dict(oldmode=subscription.mode, newmode=mode))
subscription.url = feedurl
subscription.mode = mode
subscription.save()
data = {
"hub.callback": callback_url(feedurl, base_url),
"hub.mode": mode,
"hub.topic": feedurl,
"hub.verify": verify,
"hub.verify_token": subscription.verify_token,
}
data = urllib.urlencode(data.items())
logger.debug('sending request: %s' % repr(data))
resp = None
try:
resp = urllib2.urlopen(huburl, data)
except urllib2.HTTPError, e:
if e.code != 204: # we actually expect a 204 return code
msg = 'Could not send subscription to Hub: HTTP Error %d: %s' % (e.code, e.reason)
logger.warn(msg)
raise SubscriptionError(msg)
def get(self, request):
""" Callback used by the Hub to verify the subscription request """
# received arguments: hub.mode, hub.topic, hub.challenge,
# hub.lease_seconds, hub.verify_token
mode = request.GET.get('hub.mode')
feed_url = request.GET.get('hub.topic')
challenge = request.GET.get('hub.challenge')
lease_seconds = request.GET.get('hub.lease_seconds')
verify_token = request.GET.get('hub.verify_token')
logger.debug(('received subscription-parameters: mode: %(mode)s, ' +
'topic: %(topic)s, challenge: %(challenge)s, lease_seconds: ' +
'%(lease_seconds)s, verify_token: %(verify_token)s') % \
dict(mode=mode, topic=feed_url, challenge=challenge,
lease_seconds=lease_seconds, verify_token=verify_token))
subscription = subscription_for_topic(feed_url)
if subscription is None:
logger.warn('subscription does not exist')
return HttpResponseNotFound()
if subscription.mode != mode:
logger.warn('invalid mode, %s expected' % subscription.mode)
return HttpResponseNotFound()
if subscription.verify_token != verify_token:
logger.warn('invalid verify_token, %s expected' %
subscription.verify_token)
return HttpResponseNotFound()
set_subscription_verified(subscription)
logger.info('subscription confirmed')
return HttpResponse(challenge)
