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