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: