def handle_get(self, owner, repo, latest=False):
self.init_library(owner, repo)
if self.library is None:
self.response.set_status(404)
self.response.write('could not find library: %s' %
Library.id(owner, repo))
return
if latest:
version_id = Library.default_version_for_key_async(
self.library.key).get_result()
if version_id:
version = Version.get_by_id(version_id,
parent=self.library.key)
if version is not None:
self.trigger_analysis(version_id,
version.sha,
transactional=False)
else:
versions = Version.query(Version.status == Status.ready,
ancestor=self.library.key).fetch()
for version in versions:
self.trigger_analysis(version.key.id(),
version.sha,
transactional=False)
def get(self, owner, repo, version=None):
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Content-Type'] = 'application/json'
library_key = ndb.Key(Library, Library.id(owner, repo))
if version is None:
version = yield Library.default_version_for_key_async(library_key)
if version is None:
self.response.set_status(404)
return
version_key = ndb.Key(Library, library_key.id(), Version, version)
collection_versions = yield Version.collections_for_key_async(version_key)
collection_futures = []
for collection_version in collection_versions:
collection_futures.append(LibraryMetadata.brief_async(collection_version.key.parent(), collection_version.key.id()))
collections = []
for future in collection_futures:
collection_result = yield future
if collection_result is not None:
collections.append(collection_result)
result = {
'results': collections,
'count': len(collections),
}
self.response.write(json.dumps(result))
def handle_post(self):
message_json = json.loads(
urllib.unquote(self.request.body).rstrip('='))
message = message_json['message']
data = base64.b64decode(str(message['data']))
attributes = message['attributes']
owner = attributes['owner']
repo = attributes['repo']
version = attributes['version']
error = attributes.get('error', None)
version_key = ndb.Key(Library, Library.id(owner, repo), Version,
version)
content = Content.get_by_id('analysis', parent=version_key)
if content is None:
return
if data == '':
content.set_json(None)
else:
content.set_json(json.loads(data))
if error is None:
content.status = Status.ready
content.error = None
else:
content.status = Status.error
content.error = error
content.put()
if version_key.id() == Library.default_version_for_key_async(
version_key.parent()).get_result():
task_url = util.update_indexes_task(owner, repo)
util.new_task(task_url, target='manage')
def get(self, owner, repo, version=None):
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Content-Type'] = 'application/json'
library_key = ndb.Key(Library, Library.id(owner, repo))
if version is None:
version = yield Library.default_version_for_key_async(library_key)
if version is None:
self.response.set_status(404)
return
version_key = ndb.Key(Library, library_key.id(), Version, version)
bower = yield Content.get_by_id_async('bower', parent=version_key)
if bower is None:
self.response.set_status(404)
return
bower_json = bower.get_json()
bower_dependencies = bower_json.get('dependencies', {})
dependencies = []
version_futures = []
for name in bower_dependencies.keys():
dependency = Dependency.from_string(bower_dependencies[name])
if dependency is None:
continue
dependencies.append(dependency)
dependency_library_key = ndb.Key(Library, Library.id(dependency.owner, dependency.repo))
version_futures.append(Library.versions_for_key_async(dependency_library_key))
dependency_futures = []
for i, dependency in enumerate(dependencies):
versions = yield version_futures[i]
def matches(version, spec):
try:
return versiontag.match(version, spec)
except ValueError:
# FIXME: What other cases do we need to support here?
return False
while len(versions) > 0 and not matches(versions[-1], dependency.version):
versions.pop()
if len(versions) > 0:
dependency_library_key = ndb.Key(Library, Library.id(dependency.owner.lower(), dependency.repo.lower()))
dependency_futures.append(LibraryMetadata.brief_async(dependency_library_key, versions[-1]))
results = []
for future in dependency_futures:
dependency_result = yield future
if dependency_result is not None:
results.append(dependency_result)
result = {
'results': results,
'count': len(results),
}
self.response.write(json.dumps(result))
def handle_get(self, owner, repo):
library_key = ndb.Key(Library, Library.id(owner, repo))
version = Library.default_version_for_key_async(library_key).get_result()
if version is None:
return self.error('no versions for %s' % Library.id(owner, repo))
bower_key = ndb.Key(Library, Library.id(owner, repo), Version, version, Content, 'bower')
bower_object = bower_key.get()
bower = {} if bower_object is None else json.loads(bower_object.content)
version_key = bower_key.parent()
library = version_key.parent().get()
self.update_search_index(owner, repo, version_key, library, bower)
if library.kind == 'collection':
self.update_collection_dependencies(version_key, bower)
default_version = Library.default_version_for_key_async(library_key).get_result()
if default_version is not None and default_version != version:
return self.retry('default version changed while updating indexes')
def handle_get(self, owner, repo):
library_key = ndb.Key(Library, Library.id(owner, repo))
version = Library.default_version_for_key_async(library_key).get_result()
if version is None:
return self.error('no versions for %s' % Library.id(owner, repo))
bower_key = ndb.Key(Library, Library.id(owner, repo), Version, version, Content, 'bower')
bower_object = bower_key.get()
bower = {} if bower_object is None else bower_object.get_json()
version_key = bower_key.parent()
library = version_key.parent().get()
self.update_search_index(owner, repo, version_key, library, bower)
if library.kind == 'collection':
self.update_collection_dependencies(version_key, bower)
default_version = Library.default_version_for_key_async(library_key).get_result()
if default_version is not None and default_version != version:
return self.retry('default version changed while updating indexes')
def get(self, owner, repo, ver=None):
use_analyzer_data = self.request.get('use_analyzer_data',
None) is not None
self.response.headers['Access-Control-Allow-Origin'] = '*'
owner = owner.lower()
repo = repo.lower()
library_key = ndb.Key(Library, Library.id(owner, repo))
if ver is None:
ver = yield Library.default_version_for_key_async(library_key)
if ver is None:
self.response.set_status(404)
return
version_key = ndb.Key(Library, Library.id(owner, repo), Version, ver)
analysis = Content.get_by_id('analysis',
parent=version_key,
read_policy=ndb.EVENTUAL_CONSISTENCY)
if analysis is None:
self.response.set_status(404)
return
self.response.headers['Content-Type'] = 'application/json'
result = {}
result['status'] = analysis.status
if analysis.status == Status.ready:
content = analysis.get_json()
has_analyzer_data = content.get('analyzerData', None) is not None
if use_analyzer_data and has_analyzer_data:
# Use the analyzer data fields
result['analysis'] = content['analyzerData']
else:
# Use the hydrolysis fields and delete the analyzer ones
if has_analyzer_data:
del content['analyzerData']
result['content'] = content
if analysis.status == Status.error:
result['error'] = analysis.error
if result['status'] != Status.ready:
self.response.set_status(400)
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(result))
def handle_get(self, scope, package, latest=False):
self.init_library(scope, package)
if self.library is None:
self.response.set_status(404)
self.response.write('could not find library: %s' % Library.id(scope, package))
return
if latest:
version_id = Library.default_version_for_key_async(self.library.key).get_result()
if version_id:
version = Version.get_by_id(version_id, parent=self.library.key)
if version is not None:
self.trigger_analysis(version_id, version.sha, transactional=False)
else:
versions = Version.query(Version.status == Status.ready, ancestor=self.library.key).fetch()
for version in versions:
self.trigger_analysis(version.key.id(), version.sha, transactional=False)
def handle_post(self):
# Ignore payloads larger than 5 MB.
if len(self.request.body) > 1048487 * 5:
return
message_json = json.loads(urllib.unquote(self.request.body).rstrip('='))
message = message_json['message']
data = base64.b64decode(str(message['data']))
attributes = message['attributes']
if len(attributes) == 0:
logging.error(message)
return
owner = attributes['owner']
repo = attributes['repo']
version = attributes['version']
error = attributes.get('error', None)
version_key = ndb.Key(Library, Library.id(owner, repo), Version, version)
content = Content.get_by_id('analysis', parent=version_key)
if content is None:
return
if data == '':
content.set_json(None)
else:
content.set_json(json.loads(data))
if error is None:
content.status = Status.ready
content.error = None
else:
content.status = Status.error
content.error = error
content.put()
if version_key.id() == Library.default_version_for_key_async(version_key.parent()).get_result():
task_url = util.update_indexes_task(owner, repo)
util.new_task(task_url, target='manage')
def handle_post(self):
message_json = json.loads(urllib.unquote(self.request.body).rstrip('='))
message = message_json['message']
data = base64.b64decode(str(message['data']))
attributes = message['attributes']
owner = attributes['owner']
repo = attributes['repo']
version = attributes['version']
error = attributes.get('error', None)
version_key = ndb.Key(Library, Library.id(owner, repo), Version, version)
content = Content.get_by_id('analysis', parent=version_key)
if content is None:
return
if data == '':
content.content = None
elif len(data) > 500000:
# Max entity size is only 1MB.
logging.error('content was too large: %d %s %s', len(data), Library.id(owner, repo), version)
error = 'content was too large: %d' % len(data)
else:
content.content = data
if error is None:
content.status = Status.ready
content.error = None
else:
content.status = Status.error
content.error = error
content.put()
if version_key.id() == Library.default_version_for_key_async(version_key.parent()).get_result():
task_url = util.update_indexes_task(owner, repo)
util.new_task(task_url, target='manage')
