def submit(http_request, username, encrypted_password, url, browsers):
"""
Submit a new group of screenshot requests.
Arguments
~~~~~~~~~
* username string (your user account on the server)
* encrypted_password string (lowercase hexadecimal, length 32)
* url string (request screenshots of this website)
* browsers list (platform, name and version for each browser)
Return value
~~~~~~~~~~~~
* id int (request group id)
You can use the returned request group id to check the progress of
the screenshot requests with requests.status.
"""
# Get user from database
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Fault(404, "User not found.")
# Verify authentication
nonces.verifyUser(http_request, user, encrypted_password)
# Check priority
priority = 0
if 'shotserver04.priority' in settings.INSTALLED_APPS:
from shotserver04.priority import user_priority
priority = user_priority(user)
if priority < 1:
raise Fault(402, "Priority processing is required.")
# Create domain and website if needed
url = normalize_url(url)
domain_name = extract_domain(url, remove_www=True)
domain = Domain.objects.get_or_create(name=domain_name)[0]
website = Website.objects.get_or_create(domain=domain, url=url)[0]
# Create request group
expire = datetime.now() + timedelta(minutes=30)
ip = http_request.META['REMOTE_ADDR']
request_group = RequestGroup.objects.create(website=website,
user=user,
ip=ip,
expire=expire,
priority=priority)
# Create browser requests
platforms = Platform.objects.all()
browser_groups = BrowserGroup.objects.all()
for name in browsers:
parts = name.split('_')
if len(parts) != 4:
continue
platform_name, browser_name, major, minor = parts
platform_name = platform_name.replace('-', ' ')
platform = find_by_name(platforms, platform_name)
if platform is None:
continue
browser_group = find_by_name(browser_groups, browser_name)
if browser_group is None:
continue
Request.objects.get_or_create(
request_group=request_group,
platform=platform,
browser_group=browser_group,
major=int_or_none(major),
minor=int_or_none(minor),
priority=priority,
)
return request_group.id
def start(http_request):
"""
Front page with URL input, browser chooser, and options.
"""
if (http_request.user.is_anonymous() and
hasattr(settings, 'ALLOW_ANONYMOUS_REQUESTS') and
not settings.ALLOW_ANONYMOUS_REQUESTS):
url = '/'
if http_request.META['QUERY_STRING']:
url += '?' + http_request.META['QUERY_STRING']
return error_page(http_request, _("login required"),
_("Anonymous screenshot requests are not allowed."),
u'<a href="/accounts/login/?next=%s">%s</a>' % (
urllib.quote(url.encode('utf-8')),
_("Please log in with your username and password.")))
# Initialize forms.
post = http_request.POST or None
url_form = UrlForm(post)
features_form = FeaturesForm(post)
options_form = OptionsForm(post)
special_form = SpecialForm(post)
# Get available choices from database, with correct translations.
active_factories = Factory.objects.filter(
last_poll__gte=last_poll_timeout())
active_browsers = Browser.objects.filter(
factory__in=active_factories,
active=True)
if not active_browsers:
return error_page(http_request, _("out of service"),
_("No active screenshot factories."),
_("Please try again later."))
features_form.load_choices(active_browsers)
options_form.load_choices(active_factories)
# Validate posted data.
valid_post = (url_form.is_valid() and
options_form.is_valid() and
features_form.is_valid() and
special_form.is_valid())
# Preload some database entries for browser forms
preload_foreign_keys(active_browsers,
factory=active_factories,
factory__operating_system=True,
browser_group=True,
engine=True)
# Select browsers according to GET request
selected_browsers = None
if 'browsers' in http_request.GET:
selected_browsers = http_request.GET['browsers'].split()
# Browser forms for each platform.
browser_forms = []
for platform in Platform.objects.all():
browser_form = BrowsersForm(active_browsers, platform,
post, selected_browsers)
browser_form.platform_name = \
unicode(platform).lower().replace(' ', '-')
if browser_form.is_bound:
browser_form.full_clean()
if browser_form.fields:
browser_forms.append(browser_form)
valid_post = valid_post and browser_form.is_valid()
browser_forms[0].is_first = True
browser_forms[-1].is_last = True
priority = 0
if valid_post:
if (url_form.cleaned_data['shocksite_keywords'] >
settings.SHOCKSITE_KEYWORDS_ALLOWED):
# Ignore screenshot requests for shock sites.
priority = -url_form.cleaned_data['shocksite_keywords']
elif 'shotserver04.priority' in settings.INSTALLED_APPS:
# Get priority processing for domain or user.
from shotserver04.priority import domain_priority, user_priority
priority = max(domain_priority(url_form.cleaned_data['domain']),
user_priority(http_request.user))
usage_limited = check_usage_limits(
http_request, priority,
url_form.cleaned_data['website'],
url_form.cleaned_data['domain'])
if usage_limited:
valid_post = False
if not valid_post:
# Show HTML form.
if 'url' in http_request.GET:
url_form.fields['url'].initial = http_request.GET['url']
multi_column(browser_forms)
selectors = mark_safe(',\n'.join([
SELECTOR_TEMPLATE % (plus_minus, capfirst(text))
for text, plus_minus in selector_pairs(browser_forms)]))
news_list = NewsItem.objects.all()[:10]
sponsors_list = Sponsor.objects.filter(front_page=True)
show_special_form = http_request.user.is_authenticated()
return render_to_response('start/start.html', locals(),
context_instance=RequestContext(http_request))
# Create screenshot requests and redirect to website overview.
expire = datetime.now() + timedelta(minutes=30)
values = {
'website': url_form.cleaned_data['website'],
'ip': http_request.META['REMOTE_ADDR'],
'user': None,
}
if http_request.user.is_authenticated():
values['user'] = http_request.user
values.update(options_form.cleaned_data)
values.update(features_form.cleaned_data)
values.update(special_form.cleaned_data)
match_values = {}
for key in values:
if values[key] is None:
match_values[key + '__isnull'] = True
else:
match_values[key] = values[key]
existing = RequestGroup.objects.filter(
expire__gte=datetime.now(), **match_values).order_by('-submitted')
if (len(existing) and
existing[0].request_set.filter(screenshot__isnull=True).count()):
# Previous request group is still pending, reuse it.
request_group = existing[0]
request_group.update_fields(expire=expire)
if priority > request_group.priority:
request_group.update_fields(priority=priority)
else:
request_group = RequestGroup.objects.create(
expire=expire, priority=priority, **values)
for browser_form in browser_forms:
create_platform_requests(
request_group, browser_form.platform, browser_form, priority)
# Make sure that the redirect will show the new request group
transaction.commit()
# return render_to_response('debug.html', locals(),
# context_instance=RequestContext(http_request))
return HttpResponseRedirect(values['website'].get_absolute_url())
def submit(http_request, username, encrypted_password, url, browsers):
"""
Submit a new group of screenshot requests.
Arguments
~~~~~~~~~
* username string (your user account on the server)
* encrypted_password string (lowercase hexadecimal, length 32)
* url string (request screenshots of this website)
* browsers list (platform, name and version for each browser)
Return value
~~~~~~~~~~~~
* id int (request group id)
You can use the returned request group id to check the progress of
the screenshot requests with requests.status.
"""
# Get user from database
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
raise Fault(404, "User not found.")
# Verify authentication
nonces.verifyUser(http_request, user, encrypted_password)
# Check priority
priority = 0
if 'shotserver04.priority' in settings.INSTALLED_APPS:
from shotserver04.priority import user_priority
priority = user_priority(user)
if priority < 1:
raise Fault(402, "Priority processing is required.")
# Create domain and website if needed
url = normalize_url(url)
domain_name = extract_domain(url, remove_www=True)
domain = Domain.objects.get_or_create(name=domain_name)[0]
website = Website.objects.get_or_create(domain=domain, url=url)[0]
# Create request group
expire = datetime.now() + timedelta(minutes=30)
ip = http_request.META['REMOTE_ADDR']
request_group = RequestGroup.objects.create(
website=website, user=user, ip=ip,
expire=expire, priority=priority)
# Create browser requests
platforms = Platform.objects.all()
browser_groups = BrowserGroup.objects.all()
for name in browsers:
parts = name.split('_')
if len(parts) != 4:
continue
platform_name, browser_name, major, minor = parts
platform_name = platform_name.replace('-', ' ')
platform = find_by_name(platforms, platform_name)
if platform is None:
continue
browser_group = find_by_name(browser_groups, browser_name)
if browser_group is None:
continue
Request.objects.get_or_create(
request_group=request_group,
platform=platform,
browser_group=browser_group,
major=int_or_none(major),
minor=int_or_none(minor),
priority=priority,
)
return request_group.id
