def testLoadClassFromName(self):
clazz = load_class_from_name("proxy.tests.BasicTestClass")
self.assertEqual(clazz.__name__, "BasicTestClass")
impl = clazz()
self.assertEqual(impl.test_class, "foo")
impl.test_class = "bar"
self.assertEqual(impl.test_class, "bar")
def __init_classes_with_params_from_dict__(class_dictionary):
results = {}
for entity in class_dictionary:
cls = load_class_from_name(entity)
inited_cls = cls(**class_dictionary.get(entity, {}))
results.append(inited_cls)
return results
def init_auth(cls, **initkwargs):
auth = initkwargs.get('cfg').get('auth', False)
initkwargs['auth'] = auth
if auth:
auth_backend = initkwargs.get('cfg').get('auth_provider', 'proxy.authentication.AppKeyProvider')
initkwargs['auth_provider_class'] = load_class_from_name(auth_backend)()
return initkwargs
def __init__(self, config):
try:
cache_store = load_class_from_name(config.get("function"))
self.store = cache_store(config=config)
self.endpoint_configs = {}
self.config = config
logger.info("Using cache store: %s" % config.get('function'))
except Exception as e:
logger.error("Could not initialize Cache with %s", config, exc_info=True)
def init_backend_servers(cls, **initkwargs):
server = initkwargs.get('cfg').get('server')
rotation_policy_clazz = server.get('rotation_policy', "proxy.rotations.RoundRobin")
RotationPolicyClass = load_class_from_name(rotation_policy_clazz)
actual_servers = []
for x in server.get('servers'):
actual_servers.append(convert_variable_to_env_setting(x))
initkwargs['rotation_policy'] = RotationPolicyClass(actual_servers)
return initkwargs
def init_global_config(general_json_config):
if hasattr(general_config(), "configuration_complete"):
return
start = datetime.now()
errors = "no"
logger.info(colored("-------------------------------------------------", "green"))
logger.info(colored("Face/Off Version %s" % proxy.__version__, "green"))
logger.info(colored("I'd like to take his face... off.", "green"))
logger.info(colored("-------------------------------------------------", "green"))
global_faceoff_config = general_config()
global_faceoff_config.domain_name = general_json_config.get('domain_name', None)
env_domain = os.environ.get("FACEOFF_DOMAIN_NAME", None)
overrode_domain_from_env = False
if env_domain is not None:
global_faceoff_config.domain_name = env_domain
overrode_domain_from_env = True
if global_faceoff_config.domain_name is None:
logger.warning("No domain name in your config, which could cause problems with facaded APIs that need it")
else:
logger.info("Configuring Face/Off with domain name: %s, Overrode from FACEOFF_DOMAIN_NAME env variable: %s"
% (global_faceoff_config.domain_name, overrode_domain_from_env))
global_faceoff_config.timeout = float(general_json_config.get('timeout', '.500'))
logger.info("Configuring Face/Off with timeout of %s" % global_faceoff_config.timeout)
application_object_name = general_json_config.get('application_object', None)
if application_object_name is not None:
try:
application_object = load_class_from_name(application_object_name)
global_faceoff_config.application_object = application_object
logger.info("Configuring Face/Off with application object: %s " % application_object_name)
except Exception as e:
errors = "some"
logger.error("Could not load application object with name %s" % (application_object_name,))
else:
global_faceoff_config.application_object = None
logger.warning("No application object! Can't use AppKeyProvider authentication handle")
analytic_classes = general_json_config.get('analytics', [])
analytics = ChainedAnalytics()
for analytic_class in analytic_classes:
if isinstance(analytic_class, dict):
function = analytic_class.get('function')
parameters = analytic_class.get('parameters')
elif isinstance(analytic_class, str):
function = analytic_class
parameters = {}
else:
logger.error("Could not load analytics class with config %s" % (analytic_class,))
errors = "some"
continue
try:
analytics.add_analytic(load_class_from_name(function)(**parameters))
except Exception as e:
errors = "some"
logger.error("Could not load analytics class with name %s because of %s" % (analytic_class, e))
global_faceoff_config.analytics = analytics
logger.info("Configuring Face/Off with analytics classes: %s", analytic_classes)
try:
user_provider_config = general_json_config.get('user_provider', {})
user_function = user_provider_config.get('function')
parameters = user_provider_config.get('parameters', {})
global_faceoff_config.user_provider = load_class_from_name(user_function)(**parameters)
logger.info("Configuring Face/Off with user provider config: %s", user_provider_config)
except Exception as e:
if general_json_config.get('user_provider') is None:
logger.warning("There is no user provider class, this means Face/Off can't protect endpoints by consumer keys")
else:
errors = "some"
logger.error("Could not load user provider class with config %s" % (general_json_config.get('user_provider')))
user_provider_servers = general_json_config.get('user_provider_servers', [])
global_faceoff_config.user_provider_servers = user_provider_servers
health_check = general_json_config.get('health_check_storage', {}).get('implementation', None)
if health_check is not None:
redis_health_check_config = general_json_config.get('health_check_storage')
global_faceoff_config.health_check = load_class_from_name(redis_health_check_config.get('implementation'))(**general_json_config.get('health_check_storage'))
else:
logger.warning("You have no healthcheck implementation. This probably means you have no healthchecks!")
global_faceoff_config.health_check = None
health_check_url = general_json_config.get("self_health_check_url", "proxy-check")
logger.info("Proxy self-check URL is %s", health_check_url)
if "cache" in general_json_config:
global_faceoff_config.cache = CacheManager(general_json_config.get('cache'))
else:
global_faceoff_config.cache = NoCacheManager()
application_cache().load_from_db() # fill application_cache
logger.info("Application in memory cache loaded with %s applications" % (len(application_cache().all()),))
stop = datetime.now()
if errors == "some":
color = "red"
else:
color = "green"
global_faceoff_config.configuration_complete = True
global_faceoff_config.errors_during_init = errors == "some"
logger.info(colored("-------------------------------------------------", color))
logger.info(colored("Face/Off started in %sms with %s errors" % ((stop - start).microseconds, errors), color))
logger.info(colored("-------------------------------------------------", color))
