def retrieve_bookkeeping_for_ecosystem_package(self, ecosystem, package):
"""Retrieve BookKeeping data for given Package and Ecosystem.
:param ecosystem: ecosystem for which the data should be retrieved
:param package: package for which the data should be retrieved
"""
e = Ecosystem.by_name(self.db, ecosystem)
p = Package.by_name(self.db, package)
stat = self.db.query(PackageWorkerResult).\
join(PackageAnalysis).\
filter(PackageAnalysis.package == p)
worker_stats = []
for package_worker_result in stat.all():
entry = {"worker_name": package_worker_result.worker,
"has_error": package_worker_result.error,
"task_result": package_worker_result.task_result,
"started_at": package_worker_result.started_at,
"ended_at": package_worker_result.ended_at}
worker_stats.append(entry)
version_count = self.db.query(Version).join(Package).\
filter(Package.ecosystem == e).\
filter(Version.package == p).count()
p_versions = self.db.query(Version).join(Package).join(Ecosystem).\
filter(Package.ecosystem == e).\
filter(Version.package == p)
return {"ecosystem": e.name,
"package": p.name,
"package_version_count": version_count,
"package_level_workers": worker_stats,
"analysed_versions": [v.identifier for v in p_versions]}
def retrieve_bookkeeping_for_epv(self, ecosystem, package, version):
"""Retrieve BookKeeping data for the given ecosystem, package, and version.
:param ecosystem: ecosystem for which the data should be retrieved
:param package: package for which the data should be retrieved
:param version: package version for which the data should be retrieved
"""
e = Ecosystem.by_name(self.db, ecosystem)
p = Package.by_name(self.db, package)
v = self.db.query(Version).join(Package).join(Ecosystem). \
filter(Package.ecosystem == e). \
filter(Version.package == p). \
filter(Version.identifier == version).one()
stat = self.db.query(WorkerResult).\
join(Analysis).join(Version).\
filter(Analysis.version == v)
worker_stats = []
for worker_result in stat.all():
entry = {"worker_name": worker_result.worker,
"has_error": worker_result.error,
"task_result": worker_result.task_result,
"started_at": worker_result.started_at,
"ended_at": worker_result.ended_at}
worker_stats.append(entry)
return {"ecosystem": e.name,
"package": p.name,
"version": v.identifier,
"workers": worker_stats}
def retrieve_bookkeeping_for_ecosystem_package(ecosystem, package):
"""Retrieve BookKeeping data for given Package and Ecosystem.
:param ecosystem: ecosystem for which the data should be retrieved
:param package: package for which the data should be retrieved
"""
rdb = StoragePool.get_connected_storage('BayesianPostgres')
db = rdb.session
try:
e = Ecosystem.by_name(db, ecosystem)
p = Package.by_name(db, package)
version_count = _count(
db,
db.query(Version).join(Package).filter(
Package.ecosystem == e).filter(Version.package == p))
stat = db.query(PackageWorkerResult.worker, PackageWorkerResult.error,
PackageWorkerResult.task_result).join(PackageAnalysis). \
filter(PackageAnalysis.package == p). \
all()
worker_stats = []
for worker_name, has_error, task_result in stat:
entry = {
"worker_name": worker_name,
"has_error": has_error,
"task_result": task_result
}
worker_stats.append(entry)
p_versions = db.query(Version).join(Package).join(Ecosystem). \
filter(Package.ecosystem == e). \
filter(Version.package == p)
result = {
"summary": {
"ecosystem": e.name,
"package": p.name,
"package_version_count": version_count,
"package_level_workers": worker_stats,
"analysed_versions": [v.identifier for v in p_versions]
}
}
except NoResultFound as e:
result = {"error": "No such package: %s/%s" % (ecosystem, package)}
except SQLAlchemyError as e:
result = {
"error":
"Error encountered while fetching data. Please check logs."
}
return result
def retrieve_bookkeeping_for_epv(ecosystem, package, version):
"""Retrieve BookKeeping data for the given ecosystem, package, and version.
:param ecosystem: ecosystem for which the data should be retrieved
:param package: package for which the data should be retrieved
:param version: package version for which the data should be retrieved
"""
rdb = StoragePool.get_connected_storage('BayesianPostgres')
db = rdb.session
try:
e = Ecosystem.by_name(db, ecosystem)
p = Package.by_name(db, package)
v = db.query(Version).join(Package).join(Ecosystem). \
filter(Package.ecosystem == e). \
filter(Version.package == p). \
filter(Version.identifier == version).one()
stat = db.query(WorkerResult.worker, WorkerResult.error, WorkerResult.task_result). \
join(Analysis).join(Version). \
filter(Analysis.version == v).all()
worker_stats = []
for worker_name, has_error, task_result in stat:
entry = {
"worker_name": worker_name,
"has_error": has_error,
"task_result": task_result
}
worker_stats.append(entry)
result = {
"summary": {
"ecosystem": e.name,
"package": p.name,
"version": v.identifier,
"workers": worker_stats
}
}
except NoResultFound as e:
return {
"error":
"No such version: %s/%s/%s" % (ecosystem, package, version)
}
except SQLAlchemyError as e:
result = {
"error":
"Error encountered while fetching data. Please check logs."
}
return result
