def start(config, initial=False):
if not initial:
print(
'\n\nWarning, this process should not have been started... nothing is "wrong" but it needlessly ate away a tiny bit of precious comute !\n\n'
)
config = Config(config)
if not logging.root.handlers:
rootLogger = logging.getLogger()
outStream = logging.StreamHandler(sys.stdout)
outStream.addFilter(lambda record: record.levelno <= logging.INFO)
rootLogger.addHandler(outStream)
errStream = logging.StreamHandler(sys.stderr)
errStream.addFilter(lambda record: record.levelno > logging.INFO)
rootLogger.addHandler(errStream)
initialize_static(config)
app, api = initialize_flask(config)
initialize_interfaces(config, app)
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
@api.errorhandler(Exception)
def handle_exception(e):
# pass through HTTP errors
if isinstance(e, HTTPException):
return {'message': str(e)}, e.code, e.get_response().headers
name = getattr(type(e), '__name__') or 'Unknown error'
return {'message': f'{name}: {str(e)}'}, 500
port = config['api']['http']['port']
host = config['api']['http']['host']
print(f"Start on {host}:{port}")
server = os.environ.get('MINDSDB_DEFAULT_SERVER', 'waitress')
if server.lower() == 'waitress':
serve(app, port=port, host=host)
elif server.lower() == 'flask':
app.run(debug=False, port=port, host=host)
elif server.lower() == 'gunicorn':
try:
from mindsdb.api.http.gunicorn_wrapper import StandaloneApplication
except ImportError:
print(
"Gunicorn server is not available by default. If you wish to use it, please install 'gunicorn'"
)
return
options = {
'bind': f'{host}:{port}',
'workers': min(max(multiprocessing.cpu_count(), 2), 3)
}
StandaloneApplication(app, options).run()
def start(config, verbose=False):
config = Config(config)
if verbose:
config['log']['level']['console'] = 'INFO'
initialize_log(config, 'http', wrap_print=True)
initialize_static(config)
app, api = initialize_flask(config)
initialize_interfaces(config, app)
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
@api.errorhandler(Exception)
def handle_exception(e):
# pass through HTTP errors
if isinstance(e, HTTPException):
return {'message': str(e)}, e.code, e.get_response().headers
name = getattr(type(e), '__name__') or 'Unknown error'
return {'message': f'{name}: {str(e)}'}, 500
port = config['api']['http']['port']
host = config['api']['http']['host']
server = os.environ.get('MINDSDB_DEFAULT_SERVER', 'waitress')
if server.lower() == 'waitress':
serve(app, port=port, host=host)
elif server.lower() == 'flask':
# that will 'disable access' log in console
log = logging.getLogger('werkzeug')
log.setLevel(logging.WARNING)
app.run(debug=False, port=port, host=host)
elif server.lower() == 'gunicorn':
try:
from mindsdb.api.http.gunicorn_wrapper import StandaloneApplication
except ImportError:
print(
"Gunicorn server is not available by default. If you wish to use it, please install 'gunicorn'"
)
return
options = {
'bind': f'{host}:{port}',
'workers': min(max(multiprocessing.cpu_count(), 2), 3)
}
StandaloneApplication(app, options).run()
def start(config, initial=False):
if not initial:
print('\n\nWarning, this process should not have been started... nothing is "wrong" but it needlessly ate away a tiny bit of precious comute !\n\n')
config = Config(config)
if not logging.root.handlers:
rootLogger = logging.getLogger()
outStream = logging.StreamHandler(sys.stdout)
outStream.addFilter(lambda record: record.levelno <= logging.INFO)
rootLogger.addHandler(outStream)
errStream = logging.StreamHandler(sys.stderr)
errStream.addFilter(lambda record: record.levelno > logging.INFO)
rootLogger.addHandler(errStream)
mindsdb.CONFIG.MINDSDB_DATASOURCES_PATH = os.path.join(mindsdb.CONFIG.MINDSDB_STORAGE_PATH, 'datasources')
mindsdb.CONFIG.MINDSDB_TEMP_PATH = os.path.join(mindsdb.CONFIG.MINDSDB_STORAGE_PATH, 'tmp')
os.makedirs(mindsdb.CONFIG.MINDSDB_STORAGE_PATH, exist_ok=True)
os.makedirs(mindsdb.CONFIG.MINDSDB_DATASOURCES_PATH, exist_ok=True)
os.makedirs(mindsdb.CONFIG.MINDSDB_TEMP_PATH, exist_ok=True)
app, api = initialize_flask(config)
initialize_interfaces(config, app)
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
@api.errorhandler(Exception)
def handle_exception(e):
# pass through HTTP errors
if isinstance(e, HTTPException):
return {'message': str(e)}, e.code, e.get_response().headers
name = getattr(type(e), '__name__') or 'Unknown error'
return {'message': f'{name}: {str(e)}'}, 500
port = config['api']['http']['port']
host = config['api']['http']['host']
print(f"Start on {host}:{port}")
options = {
'bind': f'{host}:{port}',
'workers': min(max(multiprocessing.cpu_count(), 2), 3)
}
StandaloneApplication(app, options).run()
def start(config, initial=False):
if not initial:
print(
'\n\nWarning, this process should not have been started... nothing is "wrong" but it needlessly ate away a tiny bit of precious comute !\n\n'
)
config = Config(config)
debug = False
if not logging.root.handlers:
rootLogger = logging.getLogger()
outStream = logging.StreamHandler(sys.stdout)
outStream.addFilter(lambda record: record.levelno <= logging.INFO)
rootLogger.addHandler(outStream)
errStream = logging.StreamHandler(sys.stderr)
errStream.addFilter(lambda record: record.levelno > logging.INFO)
rootLogger.addHandler(errStream)
mindsdb.CONFIG.MINDSDB_DATASOURCES_PATH = os.path.join(
mindsdb.CONFIG.MINDSDB_STORAGE_PATH, 'datasources')
mindsdb.CONFIG.MINDSDB_TEMP_PATH = os.path.join(
mindsdb.CONFIG.MINDSDB_STORAGE_PATH, 'tmp')
os.makedirs(mindsdb.CONFIG.MINDSDB_STORAGE_PATH, exist_ok=True)
os.makedirs(mindsdb.CONFIG.MINDSDB_DATASOURCES_PATH, exist_ok=True)
os.makedirs(mindsdb.CONFIG.MINDSDB_TEMP_PATH, exist_ok=True)
app, api = initialize_flask(config)
initialize_interfaces(config, app)
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
print(
f"Start on {config['api']['http']['host']}:{config['api']['http']['port']}"
)
app.run(debug=debug,
port=config['api']['http']['port'],
host=config['api']['http']['host'])
def start(verbose, no_studio, with_nlp):
config = Config()
initialize_log(config, 'http', wrap_print=True)
# start static initialization in a separate thread
init_static_thread = None
if not no_studio:
init_static_thread = threading.Thread(target=initialize_static)
init_static_thread.start()
app, api = initialize_flask(config, init_static_thread, no_studio)
Compress(app)
initialize_interfaces(app)
static_root = config['paths']['static']
if os.path.isabs(static_root) is False:
static_root = os.path.join(os.getcwd(), static_root)
static_root = Path(static_root)
@app.route('/', defaults={'path': ''}, methods=['GET'])
@app.route('/<path:path>', methods=['GET'])
def root_index(path):
if path.startswith('api/'):
return {'message': 'wrong query'}, 400
if static_root.joinpath(path).is_file():
return send_from_directory(static_root, path)
else:
return send_from_directory(static_root, 'index.html')
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
api.add_namespace(stream_ns)
api.add_namespace(sql_ns)
if with_nlp:
api.add_namespace(nlp_ns)
@api.errorhandler(Exception)
def handle_exception(e):
get_log('http').error(f'http exception: {e}')
# pass through HTTP errors
if isinstance(e, HTTPException):
return {'message': str(e)}, e.code, e.get_response().headers
name = getattr(type(e), '__name__') or 'Unknown error'
return {'message': f'{name}: {str(e)}'}, 500
@app.teardown_appcontext
def remove_session(*args, **kwargs):
session.close()
@app.before_request
def before_request():
company_id = request.headers.get('company-id')
if company_id is not None:
try:
company_id = int(company_id)
except Exception as e:
get_log('http').error(
f'Cloud not parse company id: {company_id} | exception: {e}'
)
company_id = None
request.company_id = company_id
request.default_store = WithKWArgsWrapper(
current_app.original_data_store, company_id=company_id)
request.model_interface = WithKWArgsWrapper(
current_app.original_model_interface, company_id=company_id)
request.integration_controller = WithKWArgsWrapper(
current_app.original_integration_controller, company_id=company_id)
port = config['api']['http']['port']
host = config['api']['http']['host']
server = os.environ.get('MINDSDB_DEFAULT_SERVER', 'waitress')
# waiting static initialization
if not no_studio:
init_static_thread.join()
if server.lower() == 'waitress':
if host in ('', '0.0.0.0'):
serve(app,
port=port,
host='*',
max_request_body_size=1073741824 * 10,
inbuf_overflow=1073741824 * 10)
else:
serve(app,
port=port,
host=host,
max_request_body_size=1073741824 * 10,
inbuf_overflow=1073741824 * 10)
elif server.lower() == 'flask':
# that will 'disable access' log in console
log = logging.getLogger('werkzeug')
log.setLevel(logging.WARNING)
app.run(debug=False, port=port, host=host)
elif server.lower() == 'gunicorn':
try:
from mindsdb.api.http.gunicorn_wrapper import StandaloneApplication
except ImportError:
print(
"Gunicorn server is not available by default. If you wish to use it, please install 'gunicorn'"
)
return
options = {
'bind': f'{host}:{port}',
'workers': min(max(mp.cpu_count(), 2), 3),
'timeout': 600,
'reuse_port': True,
'threads': 4
}
StandaloneApplication(app, options).run()
def start(verbose, no_studio):
config = Config()
if verbose:
config.set(['log', 'level', 'console'], 'DEBUG')
initialize_log(config, 'http', wrap_print=True)
# start static initialization in a separate thread
init_static_thread = None
if not no_studio:
init_static_thread = threading.Thread(target=initialize_static,
args=(config, ))
init_static_thread.start()
app, api = initialize_flask(config, init_static_thread, no_studio)
Compress(app)
initialize_interfaces(app)
static_root = config.paths['static']
if os.path.isabs(static_root) is False:
static_root = os.path.join(os.getcwd(), static_root)
static_root = Path(static_root)
@app.route('/', defaults={'path': ''}, methods=['GET'])
@app.route('/<path:path>', methods=['GET'])
def root_index(path):
if path.startswith('api/'):
return {'message': 'wrong query'}, 400
if static_root.joinpath(path).is_file():
return send_from_directory(static_root, path)
else:
return send_from_directory(static_root, 'index.html')
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
api.add_namespace(stream_ns)
@api.errorhandler(Exception)
def handle_exception(e):
get_log('http').error(f'http exception: {e}')
# pass through HTTP errors
if isinstance(e, HTTPException):
return {'message': str(e)}, e.code, e.get_response().headers
name = getattr(type(e), '__name__') or 'Unknown error'
return {'message': f'{name}: {str(e)}'}, 500
@app.teardown_appcontext
def remove_session(*args, **kwargs):
session.close()
@app.before_request
def before_request():
company_id = request.headers.get('company-id') # str
# TODO setup env according company_id, somethin like
# from .initialize import initialize_interfaces
# initialize_interfaces(current_app, company_id)
port = config['api']['http']['port']
host = config['api']['http']['host']
server = os.environ.get('MINDSDB_DEFAULT_SERVER', 'waitress')
# waiting static initialization
if not no_studio:
init_static_thread.join()
if server.lower() == 'waitress':
if host in ('', '0.0.0.0'):
serve(app, port=port, host='*')
else:
serve(app, port=port, host=host)
elif server.lower() == 'flask':
# that will 'disable access' log in console
log = logging.getLogger('werkzeug')
log.setLevel(logging.WARNING)
app.run(debug=False, port=port, host=host)
elif server.lower() == 'gunicorn':
try:
from mindsdb.api.http.gunicorn_wrapper import StandaloneApplication
except ImportError:
print(
"Gunicorn server is not available by default. If you wish to use it, please install 'gunicorn'"
)
return
options = {
'bind': f'{host}:{port}',
'workers': min(max(multiprocessing.cpu_count(), 2), 3)
}
StandaloneApplication(app, options).run()
def start(config, verbose=False):
config = Config(config)
if verbose:
config['log']['level']['console'] = 'DEBUG'
initialize_log(config, 'http', wrap_print=True)
# start static initialization in a separate thread
init_static_thread = threading.Thread(target=initialize_static,
args=(config, ))
init_static_thread.start()
app, api = initialize_flask(config, init_static_thread)
initialize_interfaces(config, app)
static_root = Path(config.paths['static'])
@app.route('/', defaults={'path': ''}, methods=['GET'])
@app.route('/<path:path>', methods=['GET'])
def root_index(path):
if path.startswith('api/'):
return {'message': 'wrong query'}, 400
if static_root.joinpath(path).is_file():
return send_from_directory(config.paths['static'], path)
else:
return send_from_directory(config.paths['static'], 'index.html')
api.add_namespace(predictor_ns)
api.add_namespace(datasource_ns)
api.add_namespace(utils_ns)
api.add_namespace(conf_ns)
@api.errorhandler(Exception)
def handle_exception(e):
# pass through HTTP errors
if isinstance(e, HTTPException):
return {'message': str(e)}, e.code, e.get_response().headers
name = getattr(type(e), '__name__') or 'Unknown error'
return {'message': f'{name}: {str(e)}'}, 500
port = config['api']['http']['port']
host = config['api']['http']['host']
server = os.environ.get('MINDSDB_DEFAULT_SERVER', 'waitress')
# waiting static initialization
init_static_thread.join()
if server.lower() == 'waitress':
serve(app, port=port, host=host)
elif server.lower() == 'flask':
# that will 'disable access' log in console
log = logging.getLogger('werkzeug')
log.setLevel(logging.WARNING)
app.run(debug=False, port=port, host=host)
elif server.lower() == 'gunicorn':
try:
from mindsdb.api.http.gunicorn_wrapper import StandaloneApplication
except ImportError:
print(
"Gunicorn server is not available by default. If you wish to use it, please install 'gunicorn'"
)
return
options = {
'bind': f'{host}:{port}',
'workers': min(max(multiprocessing.cpu_count(), 2), 3)
}
StandaloneApplication(app, options).run()
