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 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 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 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 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 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.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 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.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 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 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"]
