def crash_ids_generator(num_results): params = { '_columns': 'uuid', '_results_offset': 0, '_results_number': min(MAX_PAGE, num_results), } crashids_count = 0 while True: resp = molotov.json_request(SUPERSEARCH_API, verb='GET', params=params) hits = resp['content']['hits'] for hit in hits: crashids_count += 1 yield hit['uuid'] if crashids_count >= num_results: return total = resp['content']['total'] if not hits or crashids_count >= total: return params['_results_offset'] += MAX_PAGE params['_results_number'] = min( # MAX_PAGE is the maximum we can request MAX_PAGE, # The number of results Super Search can return to us that is # hasn't returned so far total - crashids_count, # The number of results we want that we haven't gotten, yet num_results - crashids_count)
def _setup(args): _HEADERS['Authorization'] = "Bearer %s" % _ACCESS_TOKEN calendar = molotov.json_request("%s/me/calendar" % _GCAPI, headers=_HEADERS)['content'] molotov.set_var('calendar', calendar) if _NOW: now = dateutil.parser.parse(_NOW) else: now = datetime.now() print("\nBase datetime: %s (%s)\n" % (now, _LOCAL_TZ)) molotov.set_var('now', now)
def get_test_experiments(): """ Return test experiments """ url = urljoin(get_api_url(), 'experiments/running') exp_running = molotov.json_request(url)['content'] exp_test = [(exp["id"], exp["user"]) for exp in exp_running["items"] if 'monkey' in exp['name']] # thread-safe structure for molotov workers/processes experiments = Queue() if exp_test: for exp in exp_test: experiments.put(exp) return experiments
def get_test_users(config): """ Return test users """ # thread-safe structure for molotov workers/processes users = Queue() groups = molotov.json_request(urljoin(get_api_url(), 'groups'), auth=get_auth())['content'] group = [group for group in groups if group['name'] == config['group']] # check if group exists if group: for user in group[0]['users']: users.put(user) return users
def generate(self): """Pick an identity, log in and generate the auth token.""" # If the server_url has a hash fragment, it's a storage node and # that's the secret. Otherwise it's a token server url. uid = random.randint(1, 1000000) url = urlparse(self.server_url) if url.fragment: endpoint = url._replace(fragment="", path="/1.5/" + str(uid)) self.endpoint_url = urlunparse(endpoint) data = { "uid": uid, "node": urlunparse(url._replace(fragment="")), "expires": time.time() + ASSERTION_LIFETIME, } self.auth_token = make_token(data, secret=url.fragment) self.auth_secret = derive(self.auth_token, secret=url.fragment) else: email = "user%s@%s" % (uid, MOCKMYID_DOMAIN) exp = time.time() + ASSERTION_LIFETIME + self.timeskew assertion = browserid.tests.support.make_assertion( email=email, audience=self.server_url, issuer=MOCKMYID_DOMAIN, issuer_keypair=(None, MOCKMYID_PRIVATE_KEY), exp=int(exp * 1000), ) token_url = self.server_url + "/1.0/sync/1.5" response = json_request(token_url, headers={ "Authorization": "BrowserID " + assertion, }) # Maybe timeskew between client and server? if response['status'] == 401: server_time = int(response['headers']["X-Timestamp"]) self.timeskew = server_time - int(time.time()) exp = time.time() + ASSERTION_LIFETIME + self.timeskew assertion = browserid.tests.support.make_assertion( email=email, audience=self.server_url, issuer=MOCKMYID_DOMAIN, issuer_keypair=(None, MOCKMYID_PRIVATE_KEY), exp=int(exp * 1000), ) response = json_request(token_url, headers={ "Authorization": "BrowserID " + assertion, }) if response['status'] > 299: raise ValueError(response['status']) credentials = response['content'] self.auth_token = credentials["id"].encode('ascii') self.auth_secret = credentials["key"].encode('ascii') self.endpoint_url = credentials["api_endpoint"] url = urlparse(self.endpoint_url) self.endpoint_scheme = url.scheme self.endpoint_path = url.path if ':' in url.netloc: self.endpoint_host, self.endpoint_port = url.netloc.rsplit(":", 1) else: self.endpoint_host = url.netloc if url.scheme == "http": self.endpoint_port = "80" else: self.endpoint_port = "443"
def get_test_site(config): """ Return test site """ url = urljoin(get_api_url(), 'sites') sites_dict = molotov.json_request(url)['content'] sites = [site["site"] for site in sites_dict["items"]] return [site for site in sites if config['site'] in site][0]
def init_test(args): _HEADERS['Authorization'] = "Bearer %s" % _ACCESS_TOKEN me = molotov.json_request("%s/me" % _GCAPI, headers=_HEADERS)['content'] molotov.set_var('me', me)
def regenerate(self): """Generate an auth token for the selected identity.""" # If the server_url has a hash fragment, it's a storage node and # that's the secret. Otherwise it's a token server url. uid = self.uid url = urlparse(self.server_url) if url.fragment: endpoint = url._replace( path=url.path.rstrip("/") + "/1.5/" + str(uid), fragment="", ) self.endpoint_url = urlunparse(endpoint) token_duration = ASSERTION_LIFETIME # Some storage backends use the numeric tokenserver uid, and some use # the raw fxa uid and kid. Let's include mock values for both cases, # with everything derived from the mock uid for consistency.. data = { "uid": uid, "fxa_uid": hashlib.sha256( "{}:fxa_uid".format(uid).encode("ascii")).hexdigest(), "fxa_kid": hashlib.sha256( "{}:fxa_kid".format(uid).encode("ascii")).hexdigest()[:32], "hashed_fxa_uid": hashlib.sha256("{}:hashed_fxa_uid".format(uid).encode( "ascii")).hexdigest(), "node": urlunparse(url._replace(path="", fragment="")), "expires": time.time() + token_duration, } auth_token = make_token(data, secret=url.fragment) self.auth_token = auth_token.encode("ascii") self.auth_secret = derive(auth_token, secret=url.fragment).encode("ascii") self.auth_expires_at = data["expires"] else: email = "user%s@%s" % (uid, MOCKMYID_DOMAIN) exp = time.time() + ASSERTION_LIFETIME + self.timeskew assertion = browserid.tests.support.make_assertion( email=email, audience=urlunparse(url._replace(path="")), issuer=MOCKMYID_DOMAIN, issuer_keypair=(None, MOCKMYID_PRIVATE_KEY), exp=int(exp * 1000), ) token_url = self.server_url + "/1.0/sync/1.5" response = json_request(token_url, headers={ "Authorization": "BrowserID " + assertion, }) # Maybe timeskew between client and server? if response['status'] == 401: server_time = int(response['headers']["X-Timestamp"]) self.timeskew = server_time - int(time.time()) exp = time.time() + ASSERTION_LIFETIME + self.timeskew assertion = browserid.tests.support.make_assertion( email=email, audience=self.server_url, issuer=MOCKMYID_DOMAIN, issuer_keypair=(None, MOCKMYID_PRIVATE_KEY), exp=int(exp * 1000), ) response = json_request(token_url, headers={ "Authorization": "BrowserID " + assertion, }) if response['status'] > 299: raise ValueError(response['status']) credentials = response['content'] self.auth_token = credentials["id"].encode('ascii') self.auth_secret = credentials["key"].encode('ascii') self.endpoint_url = credentials["api_endpoint"] token_duration = credentials['duration'] # Regenerate tokens when they're close to expiring # but before they actually expire, to avoid spurious 401s. self.auth_expires_at = time.time() + (token_duration * 0.5) url = urlparse(self.endpoint_url) self.endpoint_scheme = url.scheme self.endpoint_path = url.path self.host_header = url.netloc if ':' in url.netloc: self.endpoint_host, self.endpoint_port = url.netloc.rsplit(":", 1) else: self.endpoint_host = url.netloc if url.scheme == "http": self.endpoint_port = "80" else: self.endpoint_port = "443"