def get_machine_logo(self, machine_uuid): if self.silo.get_setting('get_machine_logo_error'): raise APIError(self._exception_msg) logo_path = os.path.join(WEBCATALOG_SILO_DIR, "%s.png" % machine_uuid) if not os.path.exists(logo_path): raise APIError("No logo found") with open(logo_path) as fp: return fp.read()
def list_packages(self, machine_uuid): if self.silo.get_setting('list_packages_error'): raise APIError(self._exception_msg) packages = self.silo.get_package_silo() if machine_uuid not in packages: raise APIError('Package list empty') package_list = packages[machine_uuid] if not package_list: raise APIError('Package list empty') return json.dumps(package_list)
def list_packages(self, machine_uuid): """List all packages for that machine""" package_list = self._get('packages/%s/' % machine_uuid, scheme=AUTHENTICATED_API_SCHEME) if not package_list: raise APIError('Package list empty') # FIXME: need to do this hack to transform the http request to a json format content try: package_list = json.loads(package_list[1:-1].replace("'", '"').replace("True", "true").replace("False", 'false')) except ValueError as e: raise APIError('Package list invalid: %s' % e) return package_list
def list_packages(self, machine_uuid): """List all packages for that machine""" package_list = self._get('packages/%s/' % machine_uuid, scheme=AUTHENTICATED_API_SCHEME) if not package_list: raise APIError('Package list empty') # FIXME: need to do this hack to transform the http request to a json format content try: package_list = ast.literal_eval(package_list[1:-1]) except ValueError as e: raise APIError('Package list invalid: %s' % e) return package_list
def update_machine_logo(self, machine_uuid, logo_checksum, logo_content): if self.silo.get_setting('update_machine_logo_error'): raise APIError(self._exception_msg) if not self.machineuuid_exist(machine_uuid): raise APIError('Host Not Found') image_path = os.path.join(WEBCATALOG_SILO_DIR, '%s.png' % machine_uuid) with open(image_path, 'wb+') as image_on_disk: image_on_disk.write(logo_content) hosts = self.silo.get_host_silo() hosts[machine_uuid]['logo_checksum'] = logo_checksum self.silo.save_settings(WEBCATALOG_SILO_RESULT) return json.dumps('Success')
def update_packages(self, machine_uuid, packages_checksum, package_list): if self.silo.get_setting('update_packages_error'): raise APIError(self._exception_msg) if not self.machineuuid_exist(machine_uuid): raise APIError('Host Not Found') packages = self.silo.get_package_silo() packages[machine_uuid] = package_list hosts = self.silo.get_host_silo() hosts[machine_uuid]['packages_checksum'] = packages_checksum self.silo.save_settings(WEBCATALOG_SILO_RESULT) return json.dumps('Success')
def submit_review(self, review): if self._fake_settings.get_setting('submit_review_error'): raise APIError(self._exception_msg) user = self._fake_settings.get_setting( 'reviewer_username') or random.choice(self._USERS) review_id = self._fake_settings.get_setting( 'submit_review_id') or random.randint(1, 10000) r = { "origin": review.origin, "rating": review.rating, "hide": False, "app_name": review.app_name, "language": review.language, "reviewer_username": user, "usefulness_total": 0, "usefulness_favorable": 0, "review_text": review.review_text, "date_deleted": None, "summary": review.summary, "version": review.version, "id": review_id, "date_created": time.strftime("%Y-%m-%d %H:%M:%S"), "reviewer_displayname": "Fake User", "package_name": review.package_name, "distroseries": review.distroseries } return json.dumps(r)
def flag_review(self, review_id, reason, text): if self._fake_settings.get_setting('flag_review_error'): raise APIError(self._exception_msg) mod_id = random.randint(1, 500) pkg = self._fake_settings.get_setting( 'flag_package_name') or random.choice(self._PACKAGE_NAMES) username = self._fake_settings.get_setting( 'flagger_username') or random.choice(self._USERS) f = { "user_id": random.randint(1, 500), "description": text, "review_moderation_id": mod_id, "_user_cache": self._make_user_cache(username), "summary": reason, "_review_moderation_cache": { "status": 0, "review_id": review_id, "_review_cache": self._make_fake_reviews(packagename=pkg, single_id=review_id), "moderation_text": text, "date_moderated": None, "moderator_id": None, "date_created": time.strftime("%Y-%m-%d %H:%M:%S"), "id": mod_id }, "date_created": time.strftime("%Y-%m-%d %H:%M:%S"), "id": mod_id } return json.dumps(f)
def review_stats(self, origin='any', distroseries='any', days=None, valid_days=(1, 3, 7)): if self._fake_settings.get_setting('review_stats_error'): raise APIError(self._exception_msg) if self._fake_settings.get_setting('packages_returned') > 15: quantity = 15 else: quantity = self._fake_settings.get_setting('packages_returned') stats = [] for i in range(0, quantity): s = { 'app_name': '', 'package_name': self._PACKAGE_NAMES[i], 'ratings_total': str(random.randrange(1, 200)), 'ratings_average': str(random.randrange(0, 5)) } stats.append(s) return json.dumps(stats)
def list_machines(self): if self.silo.get_setting('list_machines_error'): raise APIError(self._exception_msg) dict_of_hosts = self.silo.get_setting('hosts_metadata') # the server is returning a list result = [] for hostid in dict_of_hosts: machine = dict_of_hosts[hostid] machine['uuid'] = hostid result.append(machine) return result
def delete_machine(self, machine_uuid): if self.silo.get_setting('delete_machine_error'): raise APIError(self._exception_msg) # delete the host if exist from the entry hosts = self.silo.get_host_silo() packages = self.silo.get_package_silo() try: del (packages[machine_uuid]) except KeyError: pass # there was no package list logo_path = os.path.join(WEBCATALOG_SILO_DIR, "%s.png" % machine_uuid) try: os.remove(logo_path) except OSError: pass # there was no logo if not self.machineuuid_exist(machine_uuid): raise APIError('Host Not Found') del hosts[machine_uuid] self.silo.save_settings(WEBCATALOG_SILO_RESULT) return json.dumps('Success')
def _parse_json(json_data): """Return a Python data structure corresponding to ``json_data``. Use this rather than ``json.loads`` directly to get a richer error message when JSON data cannot be decoded. :param json_data: A string containing JSON data. :raises ValueError: If the JSON data could not be parsed. :return: A Python data structure. """ try: return json.loads(json_data) except ValueError: raise APIError('No JSON object could be decoded', body=json_data)
def get_usefulness(self, review_id=None, username=None): if not username and not review_id: return None if self._fake_settings.get_setting('get_usefulness_error'): raise APIError(self._exception_msg) #just return a single fake item if the review_id was supplied if review_id: if username: response_user = username else: response_user = random.choice(self._USERS) response = { 'username': response_user, 'useful': random.choice(['True', 'False']), 'review_id': review_id } return json.dumps([response]) #set up review ids to honour requested and also add randoms quantity = self._fake_settings.get_setting('votes_returned') id_list = self._fake_settings.get_setting('required_review_ids') id_quantity = len(id_list) #figure out if we need to accomodate requested review ids if id_quantity == 0: rand_id_start = 0 else: rand_id_start = max(id_list) votes = [] for i in range(0, quantity): #assign review ids requested if any still exist try: id = id_list[i] except IndexError: id = random.randint(rand_id_start, 10000) u = { 'username': username, 'useful': random.choice(['True', 'False']), 'review_id': id } votes.append(u) return json.dumps(votes)
def update_machine(self, machine_uuid, hostname): if self.silo.get_setting('update_machine_error'): raise APIError(self._exception_msg) # update our content dictionnary with new data or creating a new entry hosts = self.silo.get_host_silo() if self.machineuuid_exist(machine_uuid): hosts[machine_uuid]['hostname'] = hostname else: hosts[machine_uuid] = { 'hostname': hostname, 'logo_checksum': None, 'packages_checksum': None, } self.silo.save_settings(WEBCATALOG_SILO_RESULT) return json.dumps('Success')
def get_reviews(self, packagename, language='any', origin='any', distroseries='any', version='any', appname='', page=1, sort='helpful'): # work out how many reviews to return for pagination if page <= self._fake_settings.get_setting('review_pages'): num_reviews = 10 elif page == self._fake_settings.get_setting('review_pages') + 1: num_reviews = self._fake_settings.get_setting('reviews_returned') else: num_reviews = 0 if self._fake_settings.get_setting('get_reviews_error'): raise APIError(self._exception_msg) reviews = self._make_fake_reviews(packagename, num_reviews) return json.dumps(reviews)
def request_url(self, url, method, body='', headers=None): """Perform an HTTP request. You probably want to call one of the ``get``, ``post``, ``put`` methods instead. """ if headers is None: headers = {} # in offline mode either get it from the cache or return None if self._offline_mode: if method in ('POST', 'PUT'): err = "method '%s' not allowed in offline-mode" % method raise OfflineModeException(err) return self._get_from_cache(url) scheme = urlparse(url).scheme if self._auth: self._auth.sign_request(url, method, body, headers) if self._log_filename: self._dump_request(url, method, body, headers) try: response, response_body = self._http[scheme].request( url, method=method, body=body, headers=headers) except AttributeError as e: # Special case out httplib2's way of telling us unable to connect if e.args[0] == "'NoneType' object has no attribute 'makefile'": raise APIError('Unable to connect to %s' % (url, )) else: raise except socket.timeout as e: raise TimeoutError('Timed out attempting to connect to %s' % (url, )) except socket.error as e: msg = 'connecting to %s: %s' % (url, e.strerror) raise SocketError(msg) if self._log_filename: self._dump_response(response, response_body) handler = self._fail_handler(url, method, body, headers) body = handler.handle(response, response_body) return body
def server_status(self): if self.silo.get_setting('server_response_error'): raise APIError(self._exception_msg) return json.dumps('ok')
def get_review(self, review_id): if self._fake_settings.get_setting('get_review_error'): raise APIError(self._exception_msg) review = self._make_fake_reviews(single_id=review_id) return json.dumps(review)
def submit_usefulness(self, review_id, useful): if self._fake_settings.get_setting('submit_usefulness_error'): raise APIError(self._exception_msg) return json.dumps( self._fake_settings.get_setting('usefulness_response_string'))