def setUpClass(cls): cls.config = testing.setUp() settings = {} try: fileConfig(cls.get_ini()) except NoSectionError: pass load_into_settings(cls.get_ini(), settings) cls.config.add_settings(settings) metlog_wrapper = load_from_settings('metlog', cls.config.registry.settings) for logger in ('tokenserver', 'mozsvc', 'powerhose'): hook_logger(logger, metlog_wrapper.client) cls.config.registry['metlog'] = metlog_wrapper.client cls.config.include("tokenserver") load_and_register("tokenserver", cls.config) cls.backend = cls.config.registry.getUtility(INodeAssignment) cls.cluster = get_cluster( 'tokenserver.tests.mockworker.crypto_worker', numprocesses=1, background=True, # debug=True, worker_params={'config': cls.get_ini()}) cls.cluster.start() time.sleep(1.)
def setUp(self): super(TestShardedNode, self).setUp() # get the options from the config self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_sharded.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) # instantiate the backend to test self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) # adding a node with 100 slots self.backend._safe_execute( """insert into nodes (`node`, `service`, `available`, `capacity`, `current_load`, `downed`, `backoff`) values ("https://phx12", "sync-1.0", 100, 100, 0, 0, 0)""", service=_SERVICE) self.backend._safe_execute( """insert into service_pattern (`service`, `pattern`) values ("sync-1.0", "{node}/{version}/{uid}")""", service="sync-1.0") self._sqlite = self.backend._dbs['sync'][0].driver == 'pysqlite' read_endpoints(self.config)
def setUp(self): super(TestPurgeOldRecordsScript, self).setUp() # Run a testing service in a separate thread # so that we can test for proper calls being made. self.service_requests = [] self.service_node = "http://localhost:8002" self.service = make_server("localhost", 8002, self._service_app) target = self.service.serve_forever self.service_thread = threading.Thread(target=target) self.service_thread.start() # This silences nuisance on-by-default logging output. self.service.RequestHandlerClass.log_request = lambda *a: None # Make a stub tokenserver app in-line. self.config = pyramid.testing.setUp() self.ini_file = os.path.join(os.path.dirname(__file__), 'test_sql.ini') settings = {} load_into_settings(self.ini_file, settings) self.config.add_settings(settings) self.config.include("tokenserver") # Configure the node-assignment backend to talk to our test service. self.backend = self.config.registry.getUtility(INodeAssignment) self.backend.add_service("test-1.0", "{node}/1.0/{uid}") self.backend.add_node("test-1.0", self.service_node, 100)
def setUp(self): self.config = testing.setUp() # creating a test application settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("appsync") # do we have memcached support, if not # and if we use the SQL backend we need to # adapt its options if not memcache_up(): backend = self.config.registry.settings['storage.backend'] storage = self.config.registry.getUtility(IAppSyncDatabase) if backend == 'appsync.storage.sql.SQLDatabase': storage.cache = FakeCache() elif backend == 'appsync.storage.mirrored.MirroredDatabase': rw = storage._readwrite if rw.__class__.__name__ == 'SQLDatabase': rw.cache = FakeCache() wsgiapp = self.config.make_wsgi_app() retry_after = self.config.registry.settings.get( 'global.retry_after', '120') app = CatchErrors(CatchAuthError(wsgiapp, retry_after)) self.app = TestApp(app)
def setUp(self): self.path = '/1.0/sign' self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'trunion-test.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("trunion") # All of that just for this crypto.init(key=self.config.registry.settings['trunion.keyfile'], cert=self.config.registry.settings['trunion.certfile']) self.signing = crypto.KEYSTORE.cert_data self._template = dict(typ="purchase-receipt", product={ "url": "https://grumpybadgers.com", "storedata": "5169314356" }, user={ "type": "email", "value": "*****@*****.**" }, iss=crypto.KEYSTORE.cert_data['iss'], nbf=self.signing['iat'], iat=self.signing['iat'], detail="https://appstore.com/receipt/5169314356", verify="https://appstore.com/verify/5169314356")
def main(): # pragma: no cover parser = ArgumentParser('Pubsub listener pushing to websockets.') parser.add_argument('config', help='path to the config file') args, settings = parser.parse_args(), {} load_into_settings(args.config, settings) config = settings['config'] ioloop.install() sub_socket = zmq.Context().socket(zmq.SUB) sub_socket.connect(config.get('zeromq', 'sub')) sub_socket.setsockopt(zmq.SUBSCRIBE, 'PUSH') print 'SUB sub_socket on', config.get('zeromq', 'sub') loop = ioloop.IOLoop.instance() port = config.get('websockets', 'port') Push(zmqstream.ZMQStream(sub_socket, loop)) application.listen(port) print 'websockets on :%s' % port # Send a status report every 10 seconds. cfg = config.get_map('storage') storage = DottedNameResolver(None).resolve(cfg.pop('backend'))(**cfg) ip = '%s:%s' % (socket.gethostbyname(socket.getfqdn()), port) callback = partial(report_status, storage, ip) period = config.get('monitor', 'period') ioloop.PeriodicCallback(callback, period * 1000).start() # Get in the pool right away. callback() loop.start()
def test_load_into_settings(self): settings = {} load_into_settings(self.file_four, settings) self.assertEquals(settings["storage.e"], "f") self.assertEquals(settings["storage.g"], "h") self.assertEquals(settings["multi.once.storage.i"], "j") self.assertEquals(settings["multi.thrice.storage.i"], "jjj")
def main(global_config, **settings): config_file = global_config['__file__'] load_into_settings(config_file, settings) config = Configurator(root_factory=Root, settings=settings) config.registry['storage'] = configure_from_settings( 'storage', settings['config'].get_map('storage')) # Adds authorization. config.include("pyramid_multiauth") # Adds cornice. config.include("cornice") # Adds Mozilla default views. config.include("mozsvc") # Adds application-specific views. config.scan("bipostal.views") config.add_static_view('/', 'bipostal:backbone/', permission='authenticated') return config.make_wsgi_app()
def setUp(self): self.config = testing.setUp() # creating a test application settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("appsync") # do we have memcached support, if not # and if we use the SQL backend we need to # adapt its options if not memcache_up(): backend = self.config.registry.settings['storage.backend'] storage = self.config.registry.getUtility(IAppSyncDatabase) if backend == 'appsync.storage.sql.SQLDatabase': storage.cache = FakeCache() elif backend == 'appsync.storage.mirrored.MirroredDatabase': rw = storage._readwrite if rw.__class__.__name__ == 'SQLDatabase': rw.cache = FakeCache() wsgiapp = self.config.make_wsgi_app() retry_after = self.config.registry.settings.get('global.retry_after', '120') app = CatchErrors(CatchAuthError(wsgiapp, retry_after)) self.app = TestApp(app)
def setUp(self): super(TestSQLBackend, self).setUp() # get the options from the config self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_sql.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) # instantiate the backend to test self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) # adding a service and a node with 100 slots try: self.backend.add_service("sync-1.1", "{node}/1.1/{uid}") except IntegrityError: # ignore if the service was already added by another test. pass self.backend.add_node("sync-1.1", "https://phx12", 100) self._sqlite = self.backend._engine.driver == 'pysqlite' endpoints = {} load_endpoints(endpoints, self.config) get_current_registry()['endpoints_patterns'] = endpoints
def main(global_config, **settings): global logger load_into_settings(global_config['__file__'], settings) config = Configurator(root_factory=Root, settings=settings) config.include("cornice") config.include("pyramid_beaker") config.include("mozsvc") config.add_static_view(name='static', path='campaign:static') config.scan("campaign.views") logger = Logging(config, global_config['__file__']) counter = Counter(config=config, logger=logger) config.registry['storage'] = _resolve_name( settings.get('db.backend', 'campaign.storage.sql.Storage'))(config=config, logger=logger) config.registry['auth'] = configure_from_settings( 'auth', settings['config'].get_map('auth')) config.registry['logger'] = logger config.registry['counter'] = counter if settings.get('dbg.self_diag', False): self_diag(config) config.registry['logger'].log('Starting up', fields='', severity=LOG.INFORMATIONAL) return config.make_wsgi_app()
def setUpClass(cls): settings = {} load_into_settings(os.environ['PUSH_TEST_CONFIG'], settings) cls.config = settings['config'] cls.pull_socket = zmq.Context().socket(zmq.PULL) cls.pull_socket.setsockopt(zmq.LINGER, 0) cls.pull_socket.bind(cls.config.get('zeromq', 'pull'))
def setUp(self): self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_fixednode.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("tokenserver") self.backend = self.config.registry.getUtility(INodeAssignment)
def setUp(self): self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_memorynode.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("tokenserver") self.backend = self.config.registry.getUtility(INodeAssignment) self.backend.clear()
def setUp(self): self.config = testing.setUp() # creating a test application settings = {} load_into_settings(_INI, settings) self.config.add_settings(settings) self.config.include("appsync") wsgiapp = self.config.make_wsgi_app() app = CatchErrors(CatchAuthError(wsgiapp)) self.app = TestApp(app)
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) self.backend.add_service(SERVICE, PATTERN) self.backend.add_node(SERVICE, "https://phx12", 100) self.logs = LogCapture()
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) self.backend.add_service(SERVICE, "{node}/{version}/{uid}") self.backend.add_node(SERVICE, "https://phx12", 100) self.logs = LogCapture()
def setUpClass(cls): settings = {} load_into_settings(CONFIG_PATH, settings) cls.config = settings['config'] cls.arbiter = circus.get_arbiter([ {'cmd': 'python router.py %s' % CONFIG_PATH, 'shell': True} ], background=True) cls.arbiter.start() # I hope the router is set up once we're done sleeping! time.sleep(1)
def setUp(self): self.path = '/status' self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'trunion-test.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("trunion") # All of that just for this crypto.init(key=self.config.registry.settings['trunion.keyfile'], cert=self.config.registry.settings['trunion.certfile'], chain=self.config.registry.settings['trunion.chainfile'])
def setUpClass(cls): cls.config = testing.setUp() settings = {} try: fileConfig(cls.get_ini()) except NoSectionError: pass load_into_settings(cls.get_ini(), settings) cls.config.add_settings(settings) cls.config.include("tokenserver") load_and_register("tokenserver", cls.config) cls.backend = cls.config.registry.getUtility(INodeAssignment)
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) wsgiapp = self.config.make_wsgi_app() self.app = TestApp(wsgiapp) # Mock out the verifier to return successfully by default. self.mock_verifier_context = self.mock_verifier() self.mock_verifier_context.__enter__() self.logs = LogCapture()
def setUp(self): super(TestPurgeOldRecordsScript, self).setUp() # Make a stub tokenserver app in-line. self.config = pyramid.testing.setUp() self.ini_file = os.path.join(os.path.dirname(__file__), 'test_sql.ini') settings = {} load_into_settings(self.ini_file, settings) self.config.add_settings(settings) self.config.include("tokenserver") # Configure the node-assignment backend to talk to our test service. self.backend = self.config.registry.getUtility(INodeAssignment) self.backend.add_service("sync-1.1", "{node}/1.1/{uid}") self.backend.add_node("sync-1.1", self.service_node, 100)
def main(global_config, **settings): load_into_settings(global_config['__file__'], settings) config = Configurator(root_factory=Root, settings=settings) config.include("cornice") config.include("pyramid_beaker") config.include("mozsvc") config.scan("campaign.views") config.registry['storage'] = Storage(config) config.registry['auth'] = configure_from_settings('auth', settings['config'].get_map('auth')) metlog_client = client_from_stream_config( open(global_config['__file__'], 'r'), 'metlog') config.registry['metlog'] = metlog_client return config.make_wsgi_app()
def setUp(self): super(TestPurgeOldRecordsScript, self).setUp() # Make a stub tokenserver app in-line. self.config = pyramid.testing.setUp() self.ini_file = os.path.join(os.path.dirname(__file__), 'test_sql.ini') settings = {} load_into_settings(self.ini_file, settings) self.config.add_settings(settings) self.config.include("tokenserver") # Configure the node-assignment backend to talk to our test service. self.backend = self.config.registry.getUtility(INodeAssignment) self.backend.add_service("test-1.0", "{node}/1.0/{uid}") self.backend.add_node("test-1.0", self.service_node, 100)
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) wsgiapp = self.config.make_wsgi_app() wsgiapp = CatchErrors(wsgiapp) self.app = TestApp(wsgiapp) # Mock out the verifier to return successfully by default. self.mock_verifier_context = self.mock_verifier() self.mock_verifier_context.__enter__() self.logs = LogCapture()
def main(): parser = ArgumentParser('Monitor websocket servers.') parser.add_argument('config', help='path to the config file') args, settings = parser.parse_args(), {} load_into_settings(args.config, settings) config = settings['config'] # Send a status report every 10 seconds. cfg = config.get_map('storage') storage = DottedNameResolver(None).resolve(cfg.pop('backend'))(**cfg) monitor = config.get_map('monitor') print 'Checking websocket servers every %s seconds.' % monitor['period'] callback = partial(check_websocket_servers, storage, monitor['timeout']) tornado.ioloop.PeriodicCallback(callback, monitor['period'] * 1000).start() tornado.ioloop.IOLoop.instance().start()
def setUp(self): logger.debug("TestPowerService.setUp") self.config = testing.setUp() settings = {} try: fileConfig(self.get_ini()) except NoSectionError: pass load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) wsgiapp = self.config.make_wsgi_app() wsgiapp = CatchErrors(wsgiapp) self.app = TestApp(wsgiapp) time.sleep(1.)
def setUp(self): self.path = '/1.0/sign_addon' self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'trunion-test.ini') settings = {} load_into_settings(self.ini, settings) # FIXME Just have a separate INI file settings['trunion.we_are_signing'] = 'addons' self.config.add_settings(settings) self.config.include("trunion") # All of that just for this settings = self.config.registry.settings crypto.init(key=settings['trunion.keyfile'], cert=settings['trunion.certfile'], chain=settings['trunion.chainfile']) crypto.init_ca(self.sectionify(settings, 'addons'), self.sectionify(settings, 'dnbase'), self.sectionify(settings, 'extensions'))
def setUp(self): self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_fixednode.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("stokenserver") self.backend = self.config.registry.getUtility(IMetadataDB) # adding a node with 100 slots self.backend._safe_execute( """insert into nodes (`node`, `service`, `available`, `capacity`, `current_load`, `downed`, `backoff`) values ("phx12", "sync", 100, 100, 0, 0, 0)""") self._sqlite = self.backend._engine.driver == 'pysqlite' wsgiapp = self.config.make_wsgi_app() wsgiapp = CatchErrors(wsgiapp) self.app = TestApp(wsgiapp)
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) metlog_wrapper = load_from_settings('metlog', self.config.registry.settings) for logger in ('tokenserver', 'mozsvc', 'powerhose'): hook_logger(logger, metlog_wrapper.client) self.config.registry['metlog'] = metlog_wrapper.client self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) wsgiapp = self.config.make_wsgi_app() wsgiapp = CatchErrors(wsgiapp) self.app = TestApp(wsgiapp) # Mock out the verifier to return successfully by default. self.mock_verifier_context = self.mock_verifier() self.mock_verifier_context.__enter__()
def main(global_config, **settings): config_file = global_config['__file__'] load_into_settings(config_file, settings) config = Configurator(root_factory=Root, settings=settings) config.registry['queuey'] = loader(config, settings, 'queuey') config.registry['storage'] = loader(config, settings, 'storage') # Adds cornice. config.include('cornice') # Adds Mozilla default views. config.include('mozsvc') # Adds application-specific views. config.scan('push.views') config.add_static_view('/', 'push:static') return config.make_wsgi_app()
def main(global_config, **settings): global logger load_into_settings(global_config['__file__'], settings) config = Configurator(root_factory=Root, settings=settings) config.include("cornice") config.include("pyramid_beaker") config.include("mozsvc") config.add_static_view(name='static', path='campaign:static') config.scan("campaign.views") logger = Logging(config, global_config['__file__']) config.registry['storage'] = _resolve_name( settings.get('db.backend', 'campaign.storage.sql.Storage'))(config) config.registry['auth'] = configure_from_settings('auth', settings['config'].get_map('auth')) config.registry['logger'] = logger if settings.get('dbg.self_diag', False): self_diag(config) config.registry['logger'].log('Starting up', fields='', severity=LOG.INFORMATIONAL) return config.make_wsgi_app()
def setUp(self): super(TestCase, self).setUp() # get the options from the config self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_sql.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) # instantiate the backend to test self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) # adding a node with 100 slots self.backend._safe_execute( """insert into nodes (`node`, `service`, `available`, `capacity`, `current_load`, `downed`, `backoff`) values ("phx12", "sync", 100, 100, 0, 0, 0)""") self._sqlite = self.backend._engine.driver == 'pysqlite'
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) wsgiapp = self.config.make_wsgi_app() wsgiapp = CatchErrors(wsgiapp) self.app = TestApp(wsgiapp) def urlopen(url, data): # NOQA class response(object): @staticmethod def read(): key = fetch_public_key("browserid.org") return json.dumps({"public-key": key}) return response self.patched = patched_urlopen(urlopen) self.patched.__enter__()
def setUp(self): self.path = '/1.0/sign' self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'signing-test.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) self.config.include("signing") # All of that just for this signing.crypto.init(key=self.config.registry.settings['signing.keyfile'], cert=self.config.registry.settings['signing.certfile']) self.signing = signing.crypto.KEYSTORE.cert_data self._template = dict(typ="purchase-receipt", product={"url": "https://grumpybadgers.com", "storedata": "5169314356"}, user={"type": "email", "value": "*****@*****.**"}, iss=signing.crypto.KEYSTORE.cert_data['iss'], nbf=self.signing['iat'], iat=self.signing['iat'], detail="https://appstore.com/receipt/5169314356", verify="https://appstore.com/verify/5169314356")
def setUp(self): self.config = testing.setUp() settings = {} load_into_settings(self.get_ini(), settings) self.config.add_settings(settings) metlog_wrapper = load_from_settings('metlog', self.config.registry.settings) for logger in ('tokenserver', 'mozsvc', 'powerhose'): hook_logger(logger, metlog_wrapper.client) self.config.registry['metlog'] = metlog_wrapper.client self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) wsgiapp = self.config.make_wsgi_app() wsgiapp = CatchErrors(wsgiapp) self.app = TestApp(wsgiapp) self.patched = patched_supportdoc_fetching() self.patched.__enter__() # by default the conditions are accepted self.backend.set_accepted_conditions_flag('aitc-1.0', True)
def setUpClass(cls): cls.config = testing.setUp() settings = {} try: fileConfig(cls.get_ini()) except NoSectionError: pass load_into_settings(cls.get_ini(), settings) cls.config.add_settings(settings) metlog_wrapper = load_from_settings('metlog', cls.config.registry.settings) for logger in ('tokenserver', 'mozsvc', 'powerhose'): hook_logger(logger, metlog_wrapper.client) cls.config.registry['metlog'] = metlog_wrapper.client cls.config.include("tokenserver") load_and_register("tokenserver", cls.config) cls.backend = cls.config.registry.getUtility(INodeAssignment) cls.cluster = get_cluster('tokenserver.tests.mockworker.crypto_worker', numprocesses=1, background=True, #debug=True, worker_params={'config': cls.get_ini()}) cls.cluster.start() time.sleep(1.)
def main(): parser = ArgumentParser('Router to publish messages to edge nodes.') parser.add_argument('config', help='path to the config file') args, settings = parser.parse_args(), {} load_into_settings(args.config, settings) config = settings['config'] ioloop.install() loop = ioloop.IOLoop.instance() context = zmq.Context() pull_socket = context.socket(zmq.PULL) pull_socket.bind(config.get('zeromq', 'pull')) pull_stream = zmqstream.ZMQStream(pull_socket, loop) print 'PULL socket on', config.get('zeromq', 'pull') pub_socket = context.socket(zmq.PUB) pub_socket.bind(config.get('zeromq', 'pub')) pub_stream = zmqstream.ZMQStream(pub_socket, loop) print 'PUB socket on', config.get('zeromq', 'pub') Proxy(pull_stream, pub_stream) loop.start()
def setUp(self): super(TestSQLBackend, self).setUp() # get the options from the config self.config = testing.setUp() self.ini = os.path.join(os.path.dirname(__file__), 'test_sql.ini') settings = {} load_into_settings(self.ini, settings) self.config.add_settings(settings) # instantiate the backend to test self.config.include("tokenserver") load_and_register("tokenserver", self.config) self.backend = self.config.registry.getUtility(INodeAssignment) # adding a service and a node with 100 slots self.backend.add_service("sync-1.0", "{node}/{version}/{uid}") self.backend.add_node("sync-1.0", "https://phx12", 100) self._sqlite = self.backend._engine.driver == 'pysqlite' endpoints = {} load_endpoints(endpoints, self.config) get_current_registry()['endpoints_patterns'] = endpoints
from campaign.storage.metrics import Counter from datetime import date import time if __name__ == "__main__": from mozsvc.config import load_into_settings from pyramid.config import Configurator from campaign.resources import Root import sys settings = {} load_into_settings('campaign-local.ini', settings) filtered_settings = {} for key in settings.keys(): if 'app.main.' in key: filtered_settings[key[9:]] = settings[key] config = Configurator(root_factory=Root, settings=filtered_settings) counter = Counter(config) yesterday = date.fromtimestamp(time.time() - 86400).isoformat() files = sys.argv[1:] or ['logs/campaign.log.' + yesterday] for file in files: counter.parse(file)
from tokenserver.util import find_config_file from mozsvc.config import load_into_settings # this is the Alembic Config object, which provides # access to the values within the .ini file in use. config = context.config # Interpret the config file for Python logging. # This line sets up loggers basically. fileConfig(config.config_file_name) ini_file = find_config_file(config.get_main_option("token_ini")) settings = {} load_into_settings(ini_file, settings) def run_migrations_offline(): """Run migrations in 'offline' mode. This configures the context with just a URL and not an Engine, though an Engine is acceptable here as well. By skipping the Engine creation we don't even need a DBAPI to be available. Calls to context.execute() here emit the given string to the script output. """ url = settings["tokenserver.sqluri"]
from sqlalchemy.pool import NullPool from tokenserver.util import find_config_file from mozsvc.config import load_into_settings # this is the Alembic Config object, which provides # access to the values within the .ini file in use. config = context.config # Interpret the config file for Python logging. # This line sets up loggers basically. fileConfig(config.config_file_name) ini_file = find_config_file(config.get_main_option("token_ini")) settings = {} load_into_settings(ini_file, settings) def run_migrations_offline(): """Run migrations in 'offline' mode. This configures the context with just a URL and not an Engine, though an Engine is acceptable here as well. By skipping the Engine creation we don't even need a DBAPI to be available. Calls to context.execute() here emit the given string to the script output. """ url = settings["tokenserver.sqluri"]