def _get_omega_from_config(configfile, qualifier=None):
from omegaml import Omega
from omegaml import settings, _base_config
defaults = settings()
with open(configfile, 'r') as fconfig:
configs = yaml.safe_load(fconfig)
qualifier = qualifier or 'default'
if qualifier == 'default':
config = configs.get(qualifier, configs)
else:
config = configs[qualifier]
_base_config.update_from_dict(config, attrs=defaults)
settings(reload=True)
om = Omega(defaults=defaults)
return om
def _save_userconfig_from_apikey(configfile,
userid,
apikey,
api_url=None,
requested_userid=None,
view=False,
keys=None,
qualifier=None):
from omegaml import settings
defaults = settings()
api_url = ensure_api_url(api_url, defaults)
required_keys = [
'OMEGA_USERID', 'OMEGA_APIKEY', 'OMEGA_RESTAPI_URL', 'OMEGA_QUALIFIER'
]
keys = keys or []
auth_env = AuthenticationEnv.secure()
with open(configfile, 'w') as fconfig:
configs = auth_env.get_userconfig_from_api(
api_url=api_url,
userid=userid,
apikey=apikey,
requested_userid=requested_userid,
qualifier=qualifier,
view=view)
config = configs['objects'][0]['data']
config['OMEGA_RESTAPI_URL'] = api_url
config['OMEGA_QUALIFIER'] = qualifier or 'default'
config['OMEGA_USERID'] = userid
config['OMEGA_APIKEY'] = apikey
config = {
k: v
for k, v in config.items() if k in (required_keys + keys)
}
yaml.safe_dump(config, fconfig, default_flow_style=False)
print("Config is in {configfile}".format(**locals()))
def apply_mixins(self):
"""
apply mixins in defaults.OMEGA_RUNTIME_MIXINS
"""
from omegaml import settings
defaults = settings()
for mixin in defaults.OMEGA_RUNTIME_MIXINS:
extend_instance(self, mixin)
def get_omega_from_apikey(userid,
apikey,
api_url=None,
requested_userid=None,
qualifier=None,
view=False):
"""
setup an Omega instance from userid and apikey
:param userid: the userid
:param apikey: the apikey
:param api_url: the api URL
:param requested_userid: the userid to request config for. in this case userid
and apikey must for a staff user for the request to succeed
:param qualifier: the database qualifier requested. defaults to 'default'
:returns: the Omega instance configured for the given user
"""
from omegaml import Omega
from omegaml import settings, _base_config
defaults = settings()
qualifier = qualifier or 'default'
api_url = api_url or defaults.OMEGA_RESTAPI_URL
if api_url.startswith('http') or any('test' in v for v in sys.argv):
api_auth = OmegaRestApiAuth(userid, apikey)
configs = get_user_config_from_api(api_auth,
api_url=api_url,
requested_userid=requested_userid,
view=view)
configs = configs['objects'][0]['data']
elif api_url == 'local':
configs = {
k: getattr(defaults, k)
for k in dir(defaults) if k.startswith('OMEGA')
}
else:
raise ValueError('invalid api_url {}'.format(api_url))
if qualifier == 'default':
config = configs.get(qualifier, configs)
else:
config = configs[qualifier]
_base_config.update_from_dict(config)
settings(reload=True)
om = Omega(defaults=defaults)
return om
def _apply_mixins(self):
"""
apply mixins in defaults.OMEGA_MDF_APPLY_MIXINS
"""
from omegaml import settings
defaults = settings()
for mixin, applyto in defaults.OMEGA_MDF_APPLY_MIXINS:
if any(v in self.caller._applyto for v in applyto.split(',')):
extend_instance(self, mixin)
def MongoClient(*args, **kwargs):
"""
Shim function adding SSL kwargs on MongoClient instead of changing
each and every location
"""
from omegaml import settings
defaults = settings()
kwargs.update(defaults.OMEGA_MONGO_SSL_KWARGS)
return RealMongoClient(*args, **kwargs)
def _get_omega_from_apikey(userid,
apikey,
api_url=None,
requested_userid=None,
qualifier=None,
view=False):
"""
setup an Omega instance from userid and apikey
:param userid: the userid
:param apikey: the apikey
:param api_url: the api URL
:param requested_userid: the userid to request config for. in this case userid
and apikey must for a staff user for the request to succeed
:param qualifier: the database qualifier requested. defaults to 'default'
:returns: OmegaCloud instance configured for the given user
Returns:
OmegaCloud
"""
from omegaml.client.cloud import OmegaCloud
from omegaml import settings, _base_config
defaults = settings(reload=True)
qualifier = qualifier or 'default'
defaults.OMEGA_USERID = userid
defaults.OMEGA_APIKEY = apikey
defaults.OMEGA_QUALIFIER = qualifier
api_url = ensure_api_url(api_url, defaults)
auth_env = AuthenticationEnv.secure()
if api_url.startswith('http') or any('test' in v for v in sys.argv):
configs = auth_env.get_userconfig_from_api(
requested_userid=requested_userid, view=view, defaults=defaults)
configs = configs['objects'][0]['data']
elif api_url == 'local':
configs = {
k: getattr(defaults, k)
for k in dir(defaults) if k.startswith('OMEGA')
}
else:
raise ValueError('invalid api_url {}'.format(api_url))
config = configs.get(qualifier, configs)
# update
_base_config.update_from_dict(config, attrs=defaults)
_base_config.update_from_config(defaults)
_base_config.load_framework_support(defaults)
_base_config.load_user_extensions(defaults)
auth = auth_env.get_runtime_auth(defaults)
om = OmegaCloud(defaults=defaults, auth=auth)
# update config to reflect request
om.defaults.OMEGA_RESTAPI_URL = api_url
om.defaults.OMEGA_USERID = userid
om.defaults.OMEGA_APIKEY = apikey
om.defaults.OMEGA_QUALIFIER = qualifier
return om
def before_all(context):
# setup omegaml
import omegaml as om
use_fixture(splinter_browser, context)
# set url and admin password
context.web_url = os.environ.get('OMEGA_URL', 'http://localhost:5000')
context.jynb_url = os.environ.get('JUPYTER_URL', 'http://localhost:8888')
# setup environment
context.debug = os.environ.get('BEHAVE_DEBUG', False)
defaults = settings()
context.om = om.setup()
context.nbfiles = os.environ.get('BEHAVE_NBFILES', './docs/source/nb')
def get_omega_for_task(cls, task, auth=None):
"""
Get Omega instance configured for user in auth
If auth is passed, a request is made to OMEGA_RESTAPI_URL to
retrieve the configuration object for this user.
If auth is the tuple (None, None, 'default') the omegaml module
is returned, which is configured to the default instance with
authentication according to the installation. To raise an
error instead set settings OMEGA_ALLOW_TASK_DEFAULT_AUTH=False
:param auth: the OmegaRuntimeAuthentication object
:return: the Omega instance configured for the user
"""
from omegaml.util import settings
default_auth = (None, None, 'default')
is_auth_provided = lambda auth: (auth is not None and auth !=
default_auth)
defaults = settings()
if is_auth_provided(auth):
if isinstance(auth, (list, tuple)):
# we get a serialized tuple, recreate auth object
# -- this is a hack to easily support python 2/3 client/server mix
userid, apikey, qualifier = auth
# by default assume worker is in cluster
# TODO refactor this setting to eedefaults
view = defaults.OMEGA_SERVICES_INCLUSTER
om = cls.get_omega_from_apikey(userid,
apikey,
qualifier=qualifier,
view=view)
else:
raise ValueError(
'cannot parse authentication as {}'.format(auth))
elif auth == default_auth:
# we provide the default implementation as per configuration
from omegaml import _omega
om = _omega._om
if not getattr(defaults, 'OMEGA_ALLOW_TASK_DEFAULT_AUTH', True):
raise ValueError(
'Default task authentication is not allowed, got {}'.
format(auth))
else:
raise ValueError(
'missing authentication tuple as (userid, apikey, qualifier), got {}'
.format(auth))
return om
def save_userconfig_from_apikey(configfile, userid, apikey, api_url=None, requested_userid=None,
view=False):
from omegaml import settings
defaults = settings()
api_url = api_url or defaults.OMEGA_RESTAPI_URL
with open(configfile, 'w') as fconfig:
auth = OmegaRestApiAuth(userid, apikey)
configs = get_user_config_from_api(auth,
api_url=api_url,
requested_userid=requested_userid,
view=view)
config = configs['objects'][0]['data']
config['OMEGA_RESTAPI_URL'] = api_url
yaml.safe_dump(config, fconfig, default_flow_style=False)
print("Config is in {configfile}".format(**locals()))
def _get_userconfig_from_api(api_auth,
api_url=None,
requested_userid=None,
qualifier=None,
view=False):
# safe way to talk to either the remote API or the in-process test server
from omegaml import settings
defaults = settings()
api_url = ensure_api_url(api_url, defaults)
api_url += '/api/v1/config/'
api_url = api_url.replace('//api', '/api')
query = []
if requested_userid:
query.append('user={}'.format(requested_userid))
if view:
query.append('view={}'.format(int(view)))
if qualifier:
query.append('qualifier={}'.format(qualifier))
api_url += '?' + '&'.join(query)
# -- setup appropriate client API
if api_url.startswith('http'):
import requests
server = session_backoff()
server_kwargs = dict(auth=api_auth)
deserialize = lambda resp: resp.json()
elif api_url.startswith('test') or any('test' in v for v in sys.argv):
try:
from tastypie.test import TestApiClient
except ModuleNotFoundError as e:
# we need omegaee environment to proceed
raise
server = TestApiClient()
server.close = lambda: None
server_kwargs = dict(authentication=api_auth.get_credentials())
deserialize = lambda resp: json.loads(resp.content.decode('utf-8'))
else:
raise ValueError('invalid api_url {}'.format(api_url))
# -- actual logic to get configs
fail_msg = ("Not authenticated using userid {api_auth.username}"
" apikey {api_auth.apikey}, error was {resp.status_code} "
"using {api_url}\n{resp.content}")
resp = server.get(api_url, **server_kwargs)
assert resp.status_code == 200, fail_msg.format(**locals())
configs = deserialize(resp)
server.close()
return configs
def get_userconfig_from_api(cls,
api_auth=None,
api_url=None,
userid=None,
apikey=None,
requested_userid=None,
defaults=None,
qualifier=None,
view=False):
from omegaml.client.userconf import _get_userconfig_from_api, ensure_api_url
defaults = defaults or settings()
api_auth = api_auth or cls.get_restapi_auth(userid=userid,
apikey=apikey,
qualifier=qualifier,
defaults=defaults)
return _get_userconfig_from_api(api_auth,
api_url=ensure_api_url(
api_url, defaults),
qualifier=qualifier
or defaults.OMEGA_QUALIFIER,
requested_userid=requested_userid,
view=view)
def get_user_config_from_api(api_auth,
api_url=None,
requested_userid=None,
view=False):
# safe way to talk to either the remote API or the in-process test server
defaults = settings()
api_url = api_url or defaults.OMEGA_RESTAPI_URL
api_url += '/api/v1/config/'
api_url = api_url.replace('//api', '/api')
query = []
if requested_userid:
query.append('user={}'.format(requested_userid))
if view:
query.append('view={}'.format(int(view)))
api_url += '?' + '&'.join(query)
# -- setup appropriate client API
if api_url.startswith('http'):
import requests
server = requests
server_kwargs = dict(auth=api_auth)
deserialize = lambda resp: resp.json()
elif any('test' in v for v in sys.argv):
# test support
import json
from tastypie.test import TestApiClient
server = TestApiClient()
server_kwargs = dict(authentication=api_auth.get_credentials())
deserialize = lambda resp: json.loads(resp.content.decode('utf-8'))
else:
raise ValueError('invalid api_url {}'.format(api_url))
# -- actual logic to get configs
fail_msg = ("Not authenticated using userid {api_auth.username}"
" apikey {api_auth.apikey}, error was {resp.status_code} "
"using {api_url}\n{resp.content}")
resp = server.get(api_url, **server_kwargs)
assert resp.status_code == 200, fail_msg.format(**locals())
configs = deserialize(resp)
return configs
def setup(app):
from omegaml import settings
# app.add_stylesheet('custom.css')
del os.environ['DJANGO_SETTINGS_MODULE']
defaults = settings()
