def setUpClass(self):
"""Database setup before the tests."""
print("Creating a temporary datatbase...")
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
session = scoped_session(sessionmaker(bind=engine))
self.session = session
self.API_NAME = "demoapi"
self.HYDRUS_SERVER_URL = "http://hydrus.com/"
self.app = app_factory(self.API_NAME)
self.doc = doc_maker.create_doc(doc_writer_sample.api_doc.generate(),
self.HYDRUS_SERVER_URL, self.API_NAME)
test_classes = doc_parse.get_classes(self.doc.generate())
test_properties = doc_parse.get_all_properties(test_classes)
doc_parse.insert_classes(test_classes, self.session)
doc_parse.insert_properties(test_properties, self.session)
add_user(1, "test", self.session)
self.auth_header = {
"X-Authentication":
"",
"Authorization":
"Basic {}".format(b64encode(b"1:test").decode("ascii"))
}
self.wrong_id = {
"X-Authentication":
"",
"Authorization":
"Basic {}".format(b64encode(b"2:test").decode("ascii"))
}
self.wrong_pass = {
"X-Authentication":
"",
"Authorization":
"Basic {}".format(b64encode(b"1:test2").decode("ascii"))
}
print("Classes, Properties and Users added successfully.")
print("Setting up Hydrus utilities... ")
self.api_name_util = set_api_name(self.app, self.API_NAME)
self.session_util = set_session(self.app, self.session)
self.doc_util = set_doc(self.app, self.doc)
self.auth_util = set_authentication(self.app, True)
self.token_util = set_token(self.app, False)
self.client = self.app.test_client()
print("Creating utilities context... ")
self.api_name_util.__enter__()
self.session_util.__enter__()
self.doc_util.__enter__()
self.auth_util.__enter__()
self.token_util.__enter__()
self.client.__enter__()
print("Setup done, running tests...")
def test_Auth_GET(self):
"""Test for the index."""
with set_api_name(self.app, self.API_NAME):
with set_session(self.app, self.session):
with set_doc(self.app, self.doc):
with set_authentication(self.app, True):
with self.app.test_client() as client:
response_get = client.get("/" + self.API_NAME)
endpoints = json.loads(
response_get.data.decode('utf-8'))
for endpoint in endpoints:
if endpoint in self.doc.collections:
response_get = client.get(
endpoints[endpoint],
headers=self.auth_header)
assert response_get.status_code != 401
def test_client_for_auth_tests(constants, session, doc, init_db_for_auth_tests, app):
"""
Get a test flask app for testing
"""
API_NAME = constants['API_NAME']
with set_authentication(app, True):
with set_token(app, False):
with set_api_name(app, API_NAME):
with set_doc(app, doc):
with set_session(app, session):
testing_client = app.test_client()
# Establish an application context before running the tests.
ctx = app.app_context()
ctx.push()
yield testing_client
ctx.pop()
engine = create_engine(DB_URL)
print("Droping database if exist")
Base.metadata.drop_all(engine)
print("Creating models....")
Base.metadata.create_all(engine)
print("Done")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
session = sessionmaker(bind=engine)()
classes = doc_parse.get_classes(apidoc.generate())
properties = doc_parse.get_all_properties(classes)
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
app = app_factory(API_NAME)
with set_doc(app, apidoc):
with set_authentication(app, False):
with set_token(app, False):
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
with set_session(app, session):
http_server = WSGIServer(('', PORT), app)
http_server.serve_forever()
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str,
hydradoc: str, port: int, serverurl: str, token: bool,
serve: None) -> None:
"""
Python Hydrus CLI
:param adduser <tuple> : Contains the user credentials.
:param api <str> : Sets the API name for the server.
:param auth <bool> : Toggles the authentication.
:param dburl <str> : Sets the database URL.
:param hydradoc <str> : Sets the link to the HydraDoc file.
:param port <int> : Sets the API server port.
:param serverurl <str> : Sets the API server url.
:param token <bool> : Toggle token based user auth.
:param serve : Starts up the server.
:return : None.
"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html#sqlalchemy.create_engine for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = dburl
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port))
# The name of the API or the EntryPoint, the api will be at http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL)
click.echo("Creating models")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object using doc_maker
# Or you may create your own HydraDoc Documentation using doc_writer [see hydrus/hydraspec/doc_writer_sample]
click.echo("Creating the API Documentation")
apidoc = doc_maker.create_doc(json.loads(hydradoc.read()),
HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
click.echo("Adding Classes and Properties")
# Get all the classes from the doc
# You can also pass dictionary defined in hydrus/hydraspec/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc.generate())
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Adding authorized users")
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
click.echo("Starting the application")
with set_authentication(app, auth):
# Use authentication for all requests
with set_token(app, token):
with set_api_name(app, api):
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
# Start the Hydrus app
http_server = WSGIServer(('', port), app)
click.echo("Server running at:")
click.echo(HYDRUS_SERVER_URL + API_NAME)
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
print("Adding authorized users")
add_user(id_=1, paraphrase="test", session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
print("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
print("Starting the application")
with set_authentication(app, True):
# Use authentication for all requests
with set_token(app, True):
with set_api_name(app, "serverapi"):
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
# Start the Hydrus app
http_server = WSGIServer(('', 8080), app)
print("Server running at:")
print(f"{HYDRUS_SERVER_URL}{API_NAME}")
try:
http_server.serve_forever()
def startserver(adduser: Tuple, api: str, auth: bool, dburl: str,
hydradoc: str, port: int, serverurl: str, token: bool,
serve: None) -> None:
"""
Python Hydrus CLI
:param openapi: : Sets the link to the Open Api Doc file.
:param adduser <tuple> : Contains the user credentials.
:param api <str> : Sets the API name for the server.
:param auth <bool> : Toggles the authentication.
:param dburl <str> : Sets the database URL.
:param hydradoc <str> : Sets the link to the HydraDoc file
(Supported formats - [.py, .jsonld, .yaml])
:param port <int> : Sets the API server port.
:param serverurl <str> : Sets the API server url.
:param token <bool> : Toggle token based user auth.
:param serve : Starts up the server.
:return : None.
Raises:
Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml].
"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = dburl
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = "{}:{}/".format(serverurl, str(port))
# The name of the API or the EntryPoint, the api will be at
# http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL)
click.echo("Creating models")
# Add the required Models to the database
Base.metadata.create_all(engine)
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object
# using doc_maker or you may create your own HydraDoc Documentation using
# doc_writer [see hydra_python_core/doc_writer_sample]
click.echo("Creating the API Documentation")
if hydradoc:
# Getting hydradoc format
# Currently supported formats [.jsonld, .py, .yaml]
try:
hydradoc_format = hydradoc.split(".")[-1]
if hydradoc_format == 'jsonld':
with open(hydradoc, 'r') as f:
doc = json.load(f)
elif hydradoc_format == 'py':
doc = SourceFileLoader(
"doc", "./examples/drones/doc.py").load_module().doc
elif hydradoc_format == 'yaml':
with open(hydradoc, 'r') as stream:
doc = parse(yaml.load(stream))
else:
raise ("Error - hydradoc format not supported.")
click.echo("Using %s as hydradoc" % hydradoc)
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
except BaseException:
click.echo("Problem parsing specified hydradoc file, "
"using sample hydradoc as default.")
apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL,
API_NAME)
else:
click.echo("No hydradoc specified, using sample hydradoc as default.\n"
"For creating api documentation see this "
"https://www.hydraecosystem.org/01-Usage.html#newdoc\n"
"You can find the example used in examples/drones/doc.py")
apidoc = doc_maker.create_doc(api_document, HYDRUS_SERVER_URL,
API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
click.echo("Adding Classes and Properties")
# Get all the classes from the doc
# You can also pass dictionary defined in
# hydra_python_core/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc.generate())
# Get all the properties from the classes
properties = doc_parse.get_all_properties(classes)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Adding authorized users")
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
click.echo("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
click.echo("Starting the application")
with set_authentication(app, auth):
# Use authentication for all requests
with set_token(app, token):
with set_api_name(app, api):
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
# Start the Hydrus app
http_server = WSGIServer(('', port), app)
click.echo("Server running at:")
click.echo("{}{}".format(HYDRUS_SERVER_URL,
API_NAME))
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
try:
add_user(id_=1, paraphrase="test", session=session)
except UserExists:
pass
# Create a Hydrus app
app = app_factory(API_NAME)
socketio = create_socket(app, session)
#
# Nested context managers
#
# Use authentication for all requests
# Set the API Documentation
# Set HYDRUS_SERVER_URL
# Set the Database session
with set_authentication(app, AUTH), set_token(app, TOKEN), \
set_api_name(app, API_NAME), set_doc(app, apidoc), \
set_hydrus_server_url(app, HYDRUS_SERVER_URL), set_session(app, session):
if __name__ == "__main__":
# this is run only if development server is run
# Set the name of the API
socketio.run(app=app, debug=True, port=PORT)
else:
# Start the Hydrus app
http_server = WSGIServer(('', PORT), app)
logger.info(f'Running server at port {PORT}')
try:
http_server.serve_forever()
except KeyboardInterrupt:
pass
def serve(
adduser: tuple,
api: str,
auth: bool,
dburl: str,
pagination: bool,
hydradoc: str,
port: int,
pagesize: int,
serverurl: str,
token: bool,
use_db: bool,
stale_records_removal_interval: int,
) -> None:
"""
Starts up the server.
\f
:param adduser <tuple> : Contains the user credentials.
:param api <str> : Sets the API name for the server.
:param auth <bool> : Toggles the authentication.
:param dburl <str> : Sets the database URL.
:param pagination <bool>: Toggles the pagination.
:param hydradoc <str> : Sets the link to the HydraDoc file
(Supported formats - [.py, .jsonld, .yaml])
:param port <int> : Sets the API server port.
:param pagesize <int> : Sets maximum size of page(view).
:param serverurl <str> : Sets the API server url.
:param token <bool> : Toggle token based user auth.
:stable_records_removal_interval <int> : Interval period between removal
of stale modification records.
:return : None
Raises:
Error: If `hydradoc` is not of a supported format[.py, .jsonld, .yaml].
"""
# The database connection URL
# See http://docs.sqlalchemy.org/en/rel_1_0/core/engines.html for more info
# DB_URL = 'sqlite:///database.db'
DB_URL = dburl
# Define the server URL, this is what will be displayed on the Doc
HYDRUS_SERVER_URL = f"{serverurl}:{str(port)}/"
# The name of the API or the EntryPoint, the api will be at
# http://localhost/<API_NAME>
API_NAME = api
click.echo("Setting up the database")
# Create a connection to the database you want to use
engine = create_engine(DB_URL, connect_args={"check_same_thread": False})
# Define the Hydra API Documentation
# NOTE: You can use your own API Documentation and create a HydraDoc object
# using doc_maker or you may create your own HydraDoc Documentation using
# doc_writer [see hydra_python_core/doc_writer_sample]
click.echo("Creating the API Documentation")
if hydradoc:
# Getting hydradoc format
# Currently supported formats [.jsonld, .py, .yaml]
try:
hydradoc_format = hydradoc.split(".")[-1]
if hydradoc_format == "jsonld":
with open(hydradoc, "r") as f:
doc = json.load(f)
elif hydradoc_format == "py":
doc = SourceFileLoader("doc", hydradoc).load_module().doc
elif hydradoc_format == "yaml":
with open(hydradoc, "r") as stream:
doc = parse(yaml.load(stream))
else:
raise ("Error - hydradoc format not supported.")
click.echo(f"Using {hydradoc} as hydradoc")
apidoc = doc_maker.create_doc(doc, HYDRUS_SERVER_URL, API_NAME)
except BaseException:
if FOUND_DOC:
click.echo("Problem parsing specified hydradoc file"
"Using hydradoc from environment variable")
else:
click.echo("Problem parsing specified hydradoc file, "
"using sample hydradoc as default.")
apidoc = doc_maker.create_doc(APIDOC_OBJ, HYDRUS_SERVER_URL,
API_NAME)
else:
if FOUND_DOC:
click.echo(
"No hydradoc specified, using hydradoc from environment variable."
)
else:
click.echo(
"No hydradoc specified, using sample hydradoc as default.\n"
"For creating api documentation see this "
"https://www.hydraecosystem.org/01-Usage.html#newdoc\n"
"You can find the example used in hydrus/samples/hydra_doc_sample.py"
)
apidoc = doc_maker.create_doc(APIDOC_OBJ, HYDRUS_SERVER_URL, API_NAME)
# Start a session with the DB and create all classes needed by the APIDoc
session = scoped_session(sessionmaker(bind=engine))
# Get all the classes from the doc
# You can also pass dictionary defined in
# hydra_python_core/doc_writer_sample_output.py
classes = doc_parse.get_classes(apidoc)
# Insert them into the database
if use_db is False:
Base.metadata.drop_all(engine)
click.echo("Adding Classes and Properties")
create_database_tables(classes)
click.echo("Creating models")
Base.metadata.create_all(engine)
# Add authorized users and pass if they already exist
click.echo("Adding authorized users")
try:
add_user(id_=adduser[0], paraphrase=adduser[1], session=session)
except UserExists:
pass
# Insert them into the database
click.echo("Creating the application")
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME, apidoc.doc_name)
# Set the name of the API
# Create a socket for the app
socketio = create_socket(app, session)
click.echo("Starting the application")
#
# Nested context managers
#
# Use authentication for all requests
# Set the API Documentation
# Set HYDRUS_SERVER_URL
# Set the Database session
# Enable/disable pagination
# Set page size of a collection view
with set_authentication(app, auth) as _, set_token(
app, token) as _, set_api_name(app, api) as _, set_doc(
app, apidoc) as _, set_hydrus_server_url(
app, HYDRUS_SERVER_URL) as _, set_session(
app, session) as _, set_pagination(
app,
pagination) as _, set_page_size(app,
pagesize) as _:
# Run a thread to remove stale modification records at some
# interval of time.
remove_stale_modification_records(session,
stale_records_removal_interval)
# Start the hydrus app
socketio.run(app, port=port)
click.echo("Server running at:")
click.echo(f"{HYDRUS_SERVER_URL}{API_NAME}")
AUTH = True
TOKEN = True
if AUTH:
try:
add_user(id_=1, paraphrase="test", session=session)
except UserExists:
pass
# Insert them into the database
doc_parse.insert_classes(classes, session)
doc_parse.insert_properties(properties, session)
# Create a Hydrus app with the API name you want, default will be "api"
app = app_factory(API_NAME)
# Set the name of the API
with set_authentication(app, AUTH):
# Use authentication for all requests
with set_token(app, TOKEN):
with set_api_name(app, API_NAME):
# Set the API Documentation
with set_doc(app, apidoc):
# Set HYDRUS_SERVER_URL
with set_hydrus_server_url(app, HYDRUS_SERVER_URL):
# Set the Database session
with set_session(app, session):
# Start the Hydrus app
http_server = WSGIServer(('', PORT), app)
print("running server at port", PORT)
try:
http_server.serve_forever()
except KeyboardInterrupt:
