def main(): try: tornado.options.parse_command_line() application = tornado.web.Application([ (r'/', OverviewHandler), (r'/query', SingleQueryHandler), (r'/batch', BatchQueryHandler), (r'/chain', QueryChainHandler), (r'/multi_query', MultiQueryHandler), (r'/callback_and_wait', CallbackWaitHandler), ], debug=True) application.db = momoko.AsyncClient({ 'host': "localhost", 'port': 5432, 'database': "stock", 'user': "******", 'password': "******", 'min_conn': 1, 'max_conn': 10, 'cleanup_timeout': 10 }) http_server = tornado.httpserver.HTTPServer(application) http_server.listen(8888) tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: print('Exit')
def main(): try: tornado.options.parse_command_line() application = tornado.web.Application([ (r'/', OverviewHandler), (r'/query', SingleQueryHandler), (r'/batch', BatchQueryHandler), (r'/chain', QueryChainHandler), ], debug=True) application.db = momoko.AsyncClient({ 'host': settings.host, 'port': settings.port, 'database': settings.database, 'user': settings.user, 'password': settings.password, 'min_conn': settings.min_conn, 'max_conn': settings.max_conn, 'cleanup_timeout': settings.cleanup_timeout }) http_server = tornado.httpserver.HTTPServer(application) http_server.listen(8888) tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: print('Exit')
def __init__(self): self.db = momoko.AsyncClient({ 'host': options.database_host, 'port': options.database_port, 'database': options.database_name, 'user': options.database_username, 'password': options.database_password, 'min_conn': options.database_min_conn, 'max_conn': options.database_max_conn, 'cleanup_timeout': options.database_cleanup_timeout }) # Start a connection to the redis to the database ID that stores # cached versions of database read queries. Delete all of them. self.r = redis.StrictRedis( host=options.redis_hostname, port=options.redis_port, db=options.redis_database_id_for_database_results) self.r.flushdb()
def _get_database(self): return momoko.AsyncClient({ 'host': self.options['hostname'], 'port': self.options['port'], 'user': self.options['username'], 'password': self.options['password'], 'ioloop': self.configuration.io_loop })
def pg_async(): return momoko.AsyncClient({ 'host': pg_host, 'database': pg_db, 'port': pg_port, 'user': pg_user, 'password': pg_pass, 'min_conn': 1, 'max_conn': 20, 'cleanup_timeout': 5 })
def setUp(self): super(AsyncClientTest, self).setUp() self.db = momoko.AsyncClient({ 'host': settings.host, 'port': settings.port, 'database': settings.database, 'user': settings.user, 'password': settings.password, 'min_conn': settings.min_conn, 'max_conn': settings.max_conn, 'cleanup_timeout': settings.cleanup_timeout, 'ioloop': self.io_loop })
def db(self): # Create a database connection when a request handler is called # and store the connection in the application object. if not hasattr(self.application, 'db'): self.application.db = momoko.AsyncClient({ 'host': 'queue1', 'database': 'sgedb', 'user': '******', 'password': '', 'min_conn': 1, 'max_conn': 20, 'cleanup_timeout': 10 }) return self.application.db
def db(self): # Create a database connection when a request handler is called # and store the connection in the application object. if not hasattr(self.application, 'db'): self.application.db = momoko.AsyncClient({ 'host': settings.host, 'port': settings.port, 'database': settings.database, 'user': settings.user, 'password': settings.password, 'min_conn': settings.min_conn, 'max_conn': settings.max_conn, 'cleanup_timeout': settings.cleanup_timeout }) return self.application.db
class PostgresServiceTest(BaseServiceTest): def _postgres_binary_path(self): if platform.system() == 'Darwin': # Postgres binaries are in the path on OSX. return "" else: # TODO: This is Ubuntu specific. return "/usr/lib/postgresql/9.1/bin" def setUp(self): super(PostgresServiceTest, self).setUp() self.server = paasmaker.util.postgresdaemon.PostgresDaemon( self.configuration) self.server.configure( self.configuration.get_scratch_path_exists('postgres'), self._postgres_binary_path(), self.configuration.get_free_port(), '127.0.0.1', self.stop, self.stop, password="******") self.wait() self.server.start(self.stop, self.stop) result = self.wait() # Give the database a short time to settle down. self.short_wait_hack(length=0.5) #delay = raw_input("Press enter to continue.") self.registry.register( 'paasmaker.service.postgres', 'paasmaker.pacemaker.service.postgres.PostgresService', { 'hostname': '127.0.0.1', 'port': self.server.get_port(), 'username': '******', 'password': '******', 'binary_path': self._postgres_binary_path() }, 'Postgres Service') def tearDown(self): if hasattr(self, 'server'): self.server.destroy(self.stop, self.stop) self.wait(timeout=10) super(PostgresServiceTest, self).tearDown() def test_simple(self): logger = self.configuration.get_job_logger('testservice') service = self.registry.instantiate( 'paasmaker.service.postgres', paasmaker.util.plugin.MODE.SERVICE_CREATE, {}, logger=logger) service.create('test', self.success_callback, self.failure_callback) try: self.wait() except psycopg2.OperationalError, ex: # Ignore this exception - it's an async handler # trying to reconnect to the now-stopped Postgres server. pass #print str(self.credentials) self.assertTrue(self.success, "Service creation was not successful.") self.assertEquals(len(self.credentials), 6, "Service did not return expected number of keys.") #delay = raw_input("Press enter to proceed.") # Connect to the database and execute a query. db = momoko.AsyncClient({ 'host': self.credentials['hostname'], 'port': self.credentials['port'], 'user': self.credentials['username'], 'password': self.credentials['password'], 'ioloop': self.configuration.io_loop }) db.execute("CREATE TABLE foo (id integer)", callback=self.stop) result = self.wait() db.execute("INSERT INTO foo VALUES (1)", callback=self.stop) result = self.wait() db.execute("SELECT id FROM foo", callback=self.stop) result = self.wait() for row in result: self.assertEquals(row[0], 1, "Result was not as expected.") db.close() credentials_copy = self.credentials # Export the database. service.export('testlongname', credentials_copy, self.success_remove_callback, self.failure_callback, self.sink_export) self.wait() self.assertTrue(self.success, "Did not succeed to export.") self.assertIn('CREATE TABLE foo', self.export_data, "Export data missing table data.") # Now attempt to delete the service. service.remove('test', credentials_copy, self.success_remove_callback, self.failure_callback) self.wait() self.assertTrue(self.success, "Did not succeed.") self.credentials = credentials_copy # Try to export the DB again. service.export('testlongname', credentials_copy, self.success_remove_callback, self.failure_callback, self.sink_export) self.wait() self.assertFalse(self.success, "Succeeded when it should not have.") self.assertIn("FATAL", self.message, "Wrong error message.") self.credentials = credentials_copy # Create a new database and import the backup into it. service.create('test2', self.success_callback, self.failure_callback) self.wait() import_credentials = self.credentials self.assertTrue(self.success, "Did not create new database.") tempimport = tempfile.mkstemp()[1] open(tempimport, 'w').write(self.export_data) service.import_file('test2', import_credentials, tempimport, self.success_remove_callback, self.failure_callback) self.wait() self.assertTrue(self.success, "Did not successfully import.") # Connect to the database and execute a query. db = momoko.AsyncClient({ 'host': import_credentials['hostname'], 'port': import_credentials['port'], 'user': import_credentials['username'], 'password': import_credentials['password'], 'ioloop': self.configuration.io_loop }) db.execute("SELECT id FROM foo", callback=self.stop) result = self.wait() for row in result: self.assertEquals(row[0], 1, "Result was not as expected.") db.close()
def test_simple(self): # Override the plugin it registered. self.registry.register( 'paasmaker.service.postgres', 'paasmaker.pacemaker.service.managedpostgres.ManagedPostgresService', { 'port': self.configuration.get_free_port(), 'root_password': '******', 'shutdown': True }, 'Postgres Service' ) # Try starting the service. service = self.registry.instantiate( 'paasmaker.service.postgres', paasmaker.util.plugin.MODE.SERVICE_CREATE, {} ) service.create('test', self.success_callback, self.failure_callback) self.wait() self.assertTrue(self.success, "Creating managed postgres service didn't succeed.") # Some basic operations copied out of the parent test. db = momoko.AsyncClient( { 'host': self.credentials['hostname'], 'port': self.credentials['port'], 'user': self.credentials['username'], 'password': self.credentials['password'], 'ioloop': self.configuration.io_loop } ) db.execute("CREATE TABLE foo (id integer)", callback=self.stop) result = self.wait() db.execute("INSERT INTO foo VALUES (1)", callback=self.stop) result = self.wait() db.execute("SELECT id FROM foo", callback=self.stop) result = self.wait() for row in result: self.assertEquals(row[0], 1, "Result was not as expected.") db.close() # Now, shut down the instances. service.shutdown_postnotify(self.stop, self.stop) self.wait() self.short_wait_hack(length=1.0) # The port should now be free. self.assertFalse(self.configuration.port_allocator.in_use(service.options['port']), "Port was not free.") # Now start them back up again. service.startup_async_prelisten(self.stop, self.stop) self.wait() self.short_wait_hack(length=1.0) # The port should now be used. self.assertTrue(self.configuration.port_allocator.in_use(service.options['port']), "Port was not in use.") # Finally, instantiate the plugin in delete mode and delete the service. service = self.registry.instantiate( 'paasmaker.service.postgres', paasmaker.util.plugin.MODE.SERVICE_DELETE, {} ) service.remove('test', self.credentials, self.success_remove_callback, self.failure_callback) try: self.wait() except psycopg2.OperationalError, ex: # Ignore this exception - it's an async handler # trying to reconnect to the now-stopped Postgres server. pass