def can_load(self, raw, cls):
temp, options = write_temp_file(raw)
cfg = aumbry.load(aumbry.FILE, cls, options)
os.remove(temp.name)
expect(cfg.nope).to.equal('testing')
def main():
docopt(__doc__)
cfg = aumbry.load(
aumbry.FILE,
sysconfig.AppConfig,
{
'CONFIG_FILE_PATH': './config/platform/config.yml'
}
)
managercfg={}
managerConfig= configmanager.ConfigManager('./config/manager.conf')
managercfg['manager']=managerConfig
triggerConfig= configmanager.ConfigManager('./config/triggermanager.conf')
managercfg['trigger']=triggerConfig
#print triggerConfig.get_key('trigger','test_dis')
displayConfig = configmanager.ConfigManager('./config/display.conf')
managercfg['display']=displayConfig
api_app = MyService(managercfg)
gunicorn_app = GunicornApp(api_app, cfg.gunicorn)
gunicorn_app.run()
def can_use_yaml_cfg_with_handler_override(self):
with mock_ssm():
options = {
'PARAMETER_STORE_AWS_REGION': 'us-west-2',
'PARAMETER_STORE_PREFIX': '/aumbry-test',
}
expected_cfg = SampleYamlConfig()
expected_cfg.nope = 'testing'
handler = GenericHandler()
# Save Sample Config
aumbry.save(aumbry.PARAM_STORE,
expected_cfg,
options,
handler=handler)
# Retrieve back the config
cfg = aumbry.load(aumbry.PARAM_STORE,
SampleGenericConfig,
options,
handler=handler)
expect(cfg.nope).to.equal(expected_cfg.nope)
def command(arguments):
options = build_options(arguments)
file_path = arguments.path
input_handler = JsonHandler()
output_handler = None
if arguments.file_type == 'yml':
input_handler = YamlHandler()
if arguments.dest == aumbry.PARAM_STORE:
output_handler = GenericHandler()
if not has_required(arguments.dest, options):
print('Missing required options for destination type')
return 1
package_ref, _, name = arguments.config_class.partition(':')
if not name:
print('config_class: requires a package and class reference')
print('Example: my_package.sub:AppConfig')
return 1
with PikeManager([arguments.package_root]):
module = py.get_module_by_name(package_ref)
config_cls = getattr(module, name)
print('Loading Config File...')
cfg = aumbry.load(aumbry.FILE,
config_cls, {'CONFIG_FILE_PATH': file_path},
handler=input_handler)
print('Uploading Config...')
aumbry.save(arguments.dest, cfg, options, handler=output_handler)
def main():
docopt(__doc__)
cfg = aumbry.load(aumbry.FILE, AppConfig,
{'CONFIG_FILE_PATH': 'config/config.yaml'})
api_app = ProspectorService(cfg)
gunicorn_app = GunicornApp(api_app, cfg.gunicorn)
gunicorn_app.run()
def main():
docopt(__doc__)
cfg = aumbry.load(aumbry.FILE, AppConfig,
{'CONFIG_FILE_PATH': './etc/example/config.yml'})
api_app = MyService(cfg)
gunicorn_app = GunicornApp(api_app, cfg.gunicorn)
gunicorn_app.run()
def main():
# docopt(__doc__)
cfg = aumbry.load(aumbry.FILE, AppConfig,
{"CONFIG_FILE_PATH": "./etc/analyst/config.yml"})
api_app = AnalystService(cfg)
gunicorn_app = GunicornApp(api_app, cfg.gunicorn)
gunicorn_app.run()
def can_save(self, raw, cls):
cfg = cls()
cfg.nope = 'testing'
with tempfile.NamedTemporaryFile() as temp:
options = {'CONFIG_FILE_PATH': temp.name}
aumbry.save(aumbry.FILE, cfg, options)
# Load up the saved file
loaded_cfg = aumbry.load(aumbry.FILE, cls, options)
expect(loaded_cfg.nope).to.equal(cfg.nope)
def setting_a_valid_path(self):
search_paths = py.get_module_by_name('aumbry.sources').__path__
temp, options = write_temp_file(raw_yaml)
cfg = aumbry.load('file',
SampleYamlConfig,
options,
search_paths=search_paths)
os.remove(temp.name)
expect(cfg.nope).to.equal('testing')
def setUp(self):
super(AppTestCase, self).setUp()
# Assume the hypothetical `myapp` package has a
# function called `create()` to initialize and
# return a `backend.API` instance.
# self.app = myapp.create()
# self.mysqld = self.Mysqld()
cfg = aumbry.load(aumbry.FILE, AppConfig,
{'CONFIG_FILE_PATH': './etc/config.yml'})
self.app = AlterService(cfg)
self.api_version = cfg.api_version
self.prefix = 'api'
def can_successfully_load_from_consul(self):
with requests_mock.Mocker() as mock:
value = base64.b64encode(raw_yaml.encode('utf-8'))
resp = [{'Value': value.decode('utf-8')}]
mock.get('http://bam/v1/kv/test_key', text=json.dumps(resp))
options = {
'CONSUL_URI': 'http://bam',
'CONSUL_KEY': 'test_key',
}
cfg = aumbry.load(aumbry.CONSUL, SampleYamlConfig, options)
expect(cfg.nope).to.equal('testing')
def can_save_and_load(self):
cfg = SampleYamlConfig()
cfg.nope = 'testing'
with tempfile.NamedTemporaryFile() as temp:
options = {
'CONFIG_FILE_PATH': temp.name,
'CONFIG_FILE_FERNET_KEY': Fernet.generate_key().decode('utf-8')
}
aumbry.save(aumbry.FERNET, cfg, options)
# Load up the saved file
loaded_cfg = aumbry.load(aumbry.FERNET, SampleYamlConfig, options)
expect(loaded_cfg.nope).to.equal(cfg.nope)
def can_successfully_load_yaml_from_etcd(self):
with requests_mock.Mocker() as mock:
value = base64.b64encode(raw_yaml.encode('utf-8'))
resp = {
'node': {
'value': value.decode('utf-8'),
},
}
mock.get('http://bam/v2/keys/test_key', text=json.dumps(resp))
options = {
'ETCD2_URI': 'http://bam',
'ETCD2_KEY': 'test_key',
}
cfg = aumbry.load(aumbry.ETCD2, SampleYamlConfig, options)
expect(cfg.nope).to.equal('testing')
def main():
logging.basicConfig()
cfg = aumbry.load(aumbry.FILE, AppConfig)
logging.getLogger(__name__).level = parse_log_level(cfg.log_level)
logger = logging.getLogger(__name__)
logger.info('Using bayeslite version: {}'.format(bayeslite.__version__))
bdb = get_bdb(cfg, logger)
fips_cols = find_fips_cols(cfg, bdb, 'resources/national_county.txt')
logger.info("Found fips columns: {}".format(fips_cols))
api_def = read_api('api.yaml')
gunicorn_app = GunicornApp(cfg, bdb, api_def, fips_cols, logger)
gunicorn_app.run()
def can_use_preprocessors(self, raw, cls):
cfg = cls()
cfg.nope = 'testing'
with tempfile.NamedTemporaryFile() as temp:
options = {'CONFIG_FILE_PATH': temp.name}
aumbry.save(aumbry.FILE,
cfg,
options,
preprocessor=lambda data: base64.b64encode(data))
expect('testing').not_to.be_in(temp.file.read().decode('utf-8'))
# Load up the saved file
loaded_cfg = aumbry.load(
aumbry.FILE,
cls,
options,
preprocessor=lambda data: base64.b64decode(data))
expect(loaded_cfg.nope).to.equal(cfg.nope)
def main():
docopt(__doc__)
cfg = aumbry.load(
aumbry.FILE,
AppConfig,
{
'CONFIG_FILE_PATH': './src/config/config.yml'
}
)
# Create an instance of the service and serve it
api_app = BimbangalService(cfg)
# Check platform whether to run using waitress or gunicorn
if platform.system() == 'Windows':
from waitress import serve
connect(host=cfg.db['conn'])
serve(api_app, host=cfg.waitress['host'], port=cfg.waitress['port'])
else:
from .gunicorn_worker import GunicornApp
gunicorn_app = GunicornApp(api_app, cfg.gunicorn)
gunicorn_app.run()
def can_successfully_save_and_load(self):
with mock_ssm():
options = {
'PARAMETER_STORE_AWS_REGION': 'us-west-2',
'PARAMETER_STORE_PREFIX': '/aumbry-test',
}
expected_cfg = SampleGenericConfig()
expected_cfg.nope = 'testing'
expected_cfg.sample_list = ['trace']
expected_cfg.sample_dict = {'trace': 'boom'}
expected_cfg.sample_model = SampleJsonConfig()
expected_cfg.sample_model.nope = 'testing2'
# Save Sample Config
aumbry.save(aumbry.PARAM_STORE, expected_cfg, options)
# Retrieve back the config
cfg = aumbry.load(aumbry.PARAM_STORE, SampleGenericConfig, options)
expect(cfg.nope).to.equal(expected_cfg.nope)
expect(cfg.sample_dict).to.equal({'trace': 'boom'})
expect(cfg.sample_list).to.equal(expected_cfg.sample_list)
expect(cfg.sample_model.nope).to.equal(expected_cfg.sample_model.nope)
def load_config_file():
return aumbry.load(aumbry.FILE, AppConfig,
{"CONFIG_FILE_PATH": "./config.json"})
class CustomWorker(SyncWorker):
def handle_quit(self, sig, frame):
self.app.application.stop(sig)
super().handle_quit(sig, frame)
def run(self):
self.app.application.start()
super().run()
class GunicornApplication(BaseApplication):
def __init__(self, app, options=None):
self.options = options or {}
self.application = app
super().__init__()
def load_config(self):
for key, value in self.options.items():
self.cfg.set(key.lower(), value)
def load(self):
return self.application
cfg = aumbry.load(aumbry.FILE, PotionConfig,
{'CONFIG_FILE_PATH': './config/config.yml'})
app = PotionApplication(cfg)
guinicorn_app = GunicornApplication(app, cfg.gunicorn)
guinicorn_app.run()
import requests
import time
from datetime import datetime
from prospector.db.models import IPAddress, Person, Address, ZipCode
from prospector.db.manager import DBManager
import GeoIP
import reverse_geocoder as rg
from celery.schedules import crontab
from celery.utils.log import get_task_logger
from prospector.config import AppConfig
from sqlalchemy import exc
from random import randint
from bs4 import BeautifulSoup
# database config
cfg = aumbry.load(aumbry.FILE, AppConfig,
{'CONFIG_FILE_PATH': '../config/config.yaml'})
mgr = DBManager(cfg.db.connection)
app = celery.Celery('tasks',
broker='amqp://',
backend='redis://localhost:6379/0')
# logger
logger = get_task_logger(__name__)
# open the geo data file once and store it in cache memory
gi = GeoIP.open('/var/lib/geoip/GeoLiteCity.dat',
GeoIP.GEOIP_INDEX_CACHE | GeoIP.GEOIP_CHECK_CACHE)
# celery beat
app.conf.beat_schedule = {
@static_folder.getter
def static_folder(self):
return getattr(self, '_static_folder', '')
class ServerConfig(YamlConfig):
__mapping__ = {
'db': Attr('db', DatabaseConfig),
'app': Attr('app', AppConfig),
}
def __init__(self):
self.db = DatabaseConfig()
self.app = AppConfig()
cfg = aumbry.load(aumbry.FILE, ServerConfig, {
'CONFIG_FILE_PATH':
os.path.join(os.path.abspath(os.getcwd()), 'config.yml')
})
log = logging.getLogger('app')
log.setLevel(cfg.app.logger.level)
f = logging.Formatter(cfg.app.logger.format, datefmt='%d-%m-%Y %H:%M:%S')
ch = logging.StreamHandler()
ch.setFormatter(f)
log.addHandler(ch)
if cfg.app.logger.is_log_file:
cf = logging.FileHandler(filename=cfg.app.logger.file)
cf.setFormatter(f)
log.addHandler(cf)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import aumbry
class UserConfig(aumbry.JsonConfig):
__mapping__ = {"uuid": ["uuid", str]}
class ServerConfig(aumbry.JsonConfig):
__mapping__ = {"master": ["master", str], "slave": ["slave", str]}
class RpcConfig(aumbry.JsonConfig):
__mapping__ = {
"version": ["version", int],
"user": ["user", UserConfig],
"server": ["server", ServerConfig],
"port": ["port", int],
"auth_ips": ["auth_ips", list]
}
_options = {
'CONFIG_FILE_PATH': './.secret.json',
}
CONFIG = aumbry.load(aumbry.FILE, RpcConfig, _options)
# print("load app config, version: %s " % CONFIG.version)
import falcon
import aumbry
from sensat.resources import ReadingsResource
from sensat.db.connection import DatabaseConnection
from sensat.config import AppConfig
from sensat.constants import CONFIG_FILE_PATH
application = falcon.API()
config = aumbry.load(aumbry.FILE, AppConfig,
{'CONFIG_FILE_PATH': CONFIG_FILE_PATH})
dbConnection = DatabaseConnection(config.db)
readingsResource = ReadingsResource(dbConnection)
application.add_route('/readings/{boxId}/{fromDate}/{toDate}',
readingsResource)
RequireJSON(),
SQLAlchemySessionManager(self.mgr.DBSession),
Auth(cfg),
])
def start(self):
self.mgr.setup()
api_kiosk = KioskAPI(cfg)
api_dc = DcAPI(cfg)
api_user = UserAPI(cfg)
api_cashier = CashierAPI(cfg)
self.add_route('/kiosk/{method}', api_kiosk)
self.add_route('/dc/{method}', api_dc)
self.add_route('/user/{method}', api_user)
self.add_route('/cashier/{method}', api_cashier)
self.add_sink(handle404, '')
pass
def stop(self, signal):
pass
cfg = aumbry.load(
aumbry.FILE, AppConfig, {
'CONFIG_FILE_PATH':
os.path.dirname(os.path.realpath(__file__)) + '/../config/config.yml'
})
api_app = CoinpayAPI(cfg)
api_app.start()
Example Application
Usage:
backend-aness [options]
Options:
-h --help Show this screen.
"""
import aumbry
from docopt import docopt
from wsgiref import simple_server
from aness.app import AlterService
from aness.config import AppConfig
docopt(__doc__)
cfg = aumbry.load(
aumbry.FILE,
AppConfig,
{
'CONFIG_FILE_PATH': './etc/config.yml'
}
)
app = application = AlterService(cfg)
if __name__ == '__main__':
httpd = simple_server.make_server('127.0.0.1', 8001, app)
httpd.serve_forever()
def config():
return aumbry.load(aumbry.FILE, AppConfig,
{'CONFIG_FILE_PATH': './etc/config.yml'})
