def test_return_json_response_data():
"""Test valid response is returned from graph db."""
query = "g.V().count()"
status, data = g.execute(query)
logger.info([status, data])
assert status is True
r = g.return_json_response_data(data)
logger.info(r)
assert r >= 0
def test_websocket_connection():
g = BayesianGraph.instance()
result = g.V().count().toList()
assert (result is not None)
vcount = result[0]
assert (vcount >= 0)
logger.info("Connection to WebSocket endpoint: SUCCESS")
def test_execute_invalid_query():
"""Test execution of invalid query."""
invalid_query = "g.count"
status, data = g.execute(invalid_query)
logger.info([status, data])
assert status is False
assert "No such property: count for class:" in data["message"]
def test_http_connection():
result = BayesianGraph.execute("g.V().count()")
code, data = result
logger.info(result)
# logger.info code
# logger.info data
# logger.info data['result']['data']
assert (code is True)
assert (data['result']['data'][0] >= 0)
logger.info("Connection to HTTP endpoint: SUCCESS")
def create_pv_nodes(self):
"""Create Package and Version nodes, if needed."""
for pv_dict in self._cve_dict.get('affected'):
epv_dict = pv_dict.copy()
epv_dict['ecosystem'] = self._cve_dict.get('ecosystem')
query = GraphPopulator.construct_graph_nodes(epv_dict)
success, json_response = BayesianGraph.execute(query)
e = epv_dict.get('ecosystem')
p = epv_dict.get('name')
v = epv_dict.get('version')
if not success:
logger.error('Error creating nodes for {e}/{p}/{v}: {r}'.format(
e=e, p=p, v=v, r=str(json_response))
)
def handle_properties(ecosystem, package, version):
"""
Handle (update/delete) properties associated with given EPV.
Update replaces properties with the same name.
Expects JSON payload in following format:
{
"properties": [
{
"name": "cve_ids",
"value": "CVE-3005-0001:10"
}
]
}
"value" can be omitted in DELETE requests.
:param ecosystem: str, ecosystem
:param package: str, package name
:param version: str, package version
:return: 200 on success, 400 on failure
"""
# TODO: reduce cyclomatic complexity
input_json = request.get_json()
properties = input_json.get('properties')
error = flask.jsonify({'error': 'invalid input'})
if not properties:
return error, 400
input_json = {
k: GraphPopulator.sanitize_text_for_query(str(v))
for k, v in input_json.items()
}
if request.method == 'PUT':
if [
x for x in properties
if not x.get('name') or x.get('value') is None
]:
return error, 400
log_msg = '[{m}] Updating properties for {e}/{p}/{v} with payload {b}'
current_app.logger.info(
log_msg.format(m=request.method,
e=ecosystem,
p=package,
v=version,
b=input_json))
query_statement = "g.V()" \
".has('pecosystem','{ecosystem}')" \
".has('pname','{pkg_name}')" \
".has('version','{version}')".format(ecosystem=ecosystem,
pkg_name=package,
version=version)
statement = ''
if request.method in ('DELETE', 'PUT'):
# build "delete" part of the statement
drop_str = ""
for prop in properties:
drop_str += query_statement
drop_str += ".properties('{property}').drop().iterate();".format(
property=prop['name'])
statement += drop_str
if request.method == 'PUT':
# build "add" part of the statement
add_str = ""
for prop in properties:
add_str += ".property('{property}','{value}')".format(
property=prop['name'], value=prop['value'])
statement += query_statement + add_str + ';'
current_app.logger.info('Gremlin statement: {s}'.format(s=statement))
success, response_json = BayesianGraph.execute(statement)
if not success:
current_app.logger.error(
"Failed to update properties for {e}/{p}/{v}".format(e=ecosystem,
p=package,
v=version))
return flask.jsonify(response_json), 400
return flask.jsonify(response_json), 200
import logging
import config
import traceback
from minio import Minio
from minio.error import ResponseError, BucketAlreadyOwnedByYou, BucketAlreadyExists
from data_importer import import_epv_from_s3_http
from graph_manager import BayesianGraph
logging.basicConfig()
logger = logging.getLogger(__name__)
# Check whether schema is created or not
# populate schema if not already done
try:
status, json_result = BayesianGraph.populate_schema()
except Exception as exc:
# Py2 compatibility: switch to "from exc" once we're on Py3
new_exc = RuntimeError("Failed to initialize graph schema")
new_exc.__cause__ = exc
raise new_exc
if status:
logger.info("Graph Schema Created")
else:
logger.error(json_result)
raise RuntimeError("Failed to setup graph schema")
def test_create_minio_bucket():
"""Test if buckets can be put into the Minio storage."""
import data_importer
from graph_manager import BayesianGraph
# Python2.x: Make default encoding as UTF-8
if sys.version_info.major == 2:
reload(sys)
sys.setdefaultencoding('UTF8')
app = Flask(__name__)
app.config.from_object('config')
CORS(app)
# Check whether schema is created or not
# populate schema if not already done
if not BayesianGraph.is_index_created():
print("Index is not created as yet, checking schema creation")
app.logger.info("Index is not created as yet, checking schema creation")
if not BayesianGraph.is_schema_defined():
print("Schema is not yet created, creating now...")
BayesianGraph.populate_schema()
# double check
schema_definition_success = BayesianGraph.is_schema_defined()
print("Double check: schema_definition_success %s" % schema_definition_success)
if not schema_definition_success:
raise RuntimeError("Failed to setup graph schema")
else:
print("Ready to serve requests")
else:
print("Ready to serve requests")
def g(self):
return BayesianGraph.instance()
def test_is_schema_defined():
"""Test if schema was initialized correctly."""
status = g.is_schema_defined()
logger.info(status)
assert status is True
def test_is_index_created():
"""Test validity created index."""
status = g.is_index_created()
logger.info(status)
assert status is False
